Initial commit

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;
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+/* loaded from: classes.dex */
+public class ToStringConverter extends AbstractSingleValueConverter {
+    private static final Class[] STRING_PARAMETER;
+    static /* synthetic */ Class class$java$lang$String;
+    private final Class clazz;
+    private final Constructor ctor;
+
+    static {
+        Class[] clsArr = new Class[1];
+        Class cls = class$java$lang$String;
+        if (cls == null) {
+            cls = class$("java.lang.String");
+            class$java$lang$String = cls;
+        }
+        clsArr[0] = cls;
+        STRING_PARAMETER = clsArr;
+    }
+
+    public ToStringConverter(Class cls) throws NoSuchMethodException {
+        this.clazz = cls;
+        this.ctor = cls.getConstructor(STRING_PARAMETER);
+    }
+
+    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) {
+        return cls == this.clazz;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return this.ctor.newInstance(str);
+        } catch (IllegalAccessException e) {
+            throw new ObjectAccessException("Unable to access single String param constructor", e);
+        } catch (InstantiationException e2) {
+            throw new ConversionException("Unable to instantiate single String param constructor", e2);
+        } catch (InvocationTargetException e3) {
+            throw new ConversionException("Unable to target single String param constructor", e3.getTargetException());
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return obj.toString();
+    }
+}

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

@@ -0,0 +1,83 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.core.util.DependencyInjectionFactory;
+import com.thoughtworks.xstream.mapper.AttributeMapper;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+class UseAttributeForEnumMapper extends AttributeMapper {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$DefaultMapper;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper;
+    static /* synthetic */ Class class$java$lang$Object;
+
+    public UseAttributeForEnumMapper(Mapper mapper) {
+        super(mapper, null, null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    static Mapper createEnumMapper(Mapper mapper) {
+        Class cls;
+        Class cls2;
+        try {
+            if (class$com$thoughtworks$xstream$mapper$Mapper == null) {
+                cls = class$("com.thoughtworks.xstream.mapper.Mapper");
+                class$com$thoughtworks$xstream$mapper$Mapper = cls;
+            } else {
+                cls = class$com$thoughtworks$xstream$mapper$Mapper;
+            }
+            Class<?> cls3 = Class.forName("com.thoughtworks.xstream.mapper.EnumMapper", true, cls.getClassLoader());
+            Object[] objArr = new Object[1];
+            if (class$com$thoughtworks$xstream$mapper$DefaultMapper == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.DefaultMapper");
+                class$com$thoughtworks$xstream$mapper$DefaultMapper = cls2;
+            } else {
+                cls2 = class$com$thoughtworks$xstream$mapper$DefaultMapper;
+            }
+            objArr[0] = new UseAttributeForEnumMapper(mapper.lookupMapperOfType(cls2));
+            return (Mapper) DependencyInjectionFactory.newInstance(cls3, objArr);
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    public static boolean isEnum(Class cls) {
+        while (cls != null) {
+            Class cls2 = class$java$lang$Object;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Object");
+                class$java$lang$Object = cls2;
+            }
+            if (cls == cls2) {
+                return false;
+            }
+            if (cls.getName().equals("java.lang.Enum")) {
+                return true;
+            }
+            cls = cls.getSuperclass();
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.mapper.AttributeMapper, com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
+    public SingleValueConverter getConverterFromAttribute(Class cls, String str, Class cls2) {
+        return null;
+    }
+
+    @Override // com.thoughtworks.xstream.mapper.AttributeMapper, com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
+    public SingleValueConverter getConverterFromItemType(String str, Class cls, Class cls2) {
+        return null;
+    }
+
+    @Override // com.thoughtworks.xstream.mapper.AttributeMapper
+    public boolean shouldLookForSingleValueConverter(String str, Class cls, Class cls2) {
+        return isEnum(cls);
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/BeanProperty.java

@@ -0,0 +1,83 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.UndeclaredThrowableException;
+
+/* loaded from: classes.dex */
+public class BeanProperty {
+    private static final Object[] EMPTY_ARGS = new Object[0];
+    protected Method getter;
+    private Class memberClass;
+    private String propertyName;
+    private Method setter;
+    private Class type;
+
+    public BeanProperty(Class cls, String str, Class cls2) {
+        this.memberClass = cls;
+        this.propertyName = str;
+        this.type = cls2;
+    }
+
+    public Object get(Object obj) throws IllegalArgumentException, IllegalAccessException {
+        if (isReadable()) {
+            try {
+                return this.getter.invoke(obj, EMPTY_ARGS);
+            } catch (InvocationTargetException e) {
+                throw new UndeclaredThrowableException(e.getTargetException());
+            }
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("Property ");
+        stringBuffer.append(this.propertyName);
+        stringBuffer.append(" of ");
+        stringBuffer.append(this.memberClass);
+        stringBuffer.append(" not readable");
+        throw new IllegalStateException(stringBuffer.toString());
+    }
+
+    public Class getBeanClass() {
+        return this.memberClass;
+    }
+
+    public String getName() {
+        return this.propertyName;
+    }
+
+    public Class getType() {
+        return this.type;
+    }
+
+    public boolean isReadable() {
+        return this.getter != null;
+    }
+
+    public boolean isWritable() {
+        return this.setter != null;
+    }
+
+    public Object set(Object obj, Object obj2) throws IllegalArgumentException, IllegalAccessException {
+        if (isWritable()) {
+            try {
+                return this.setter.invoke(obj, obj2);
+            } catch (InvocationTargetException e) {
+                throw new UndeclaredThrowableException(e.getTargetException());
+            }
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("Property ");
+        stringBuffer.append(this.propertyName);
+        stringBuffer.append(" of ");
+        stringBuffer.append(this.memberClass);
+        stringBuffer.append(" not writable");
+        throw new IllegalStateException(stringBuffer.toString());
+    }
+
+    public void setGetterMethod(Method method) {
+        this.getter = method;
+    }
+
+    public void setSetterMethod(Method method) {
+        this.setter = method;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/BeanProvider.java

@@ -0,0 +1,169 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.ErrorWritingException;
+import com.thoughtworks.xstream.converters.javabean.JavaBeanProvider;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class BeanProvider implements JavaBeanProvider {
+    protected static final Object[] NO_PARAMS = new Object[0];
+    protected PropertyDictionary propertyDictionary;
+
+    public interface Visitor extends JavaBeanProvider.Visitor {
+    }
+
+    public BeanProvider() {
+        this(new PropertyDictionary(new NativePropertySorter()));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public boolean canInstantiate(Class cls) {
+        if (cls == null) {
+            return false;
+        }
+        try {
+            return newInstance(cls) != null;
+        } catch (ErrorWritingException unused) {
+            return false;
+        }
+    }
+
+    protected boolean canStreamProperty(PropertyDescriptor propertyDescriptor) {
+        return (propertyDescriptor.getReadMethod() == null || propertyDescriptor.getWriteMethod() == null) ? false : true;
+    }
+
+    protected Constructor getDefaultConstrutor(Class cls) {
+        for (Constructor<?> constructor : cls.getConstructors()) {
+            if (constructor.getParameterTypes().length == 0 && Modifier.isPublic(constructor.getModifiers())) {
+                return constructor;
+            }
+        }
+        return null;
+    }
+
+    protected PropertyDescriptor getProperty(String str, Class cls) {
+        return this.propertyDictionary.propertyDescriptor(cls, str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public Class getPropertyType(Object obj, String str) {
+        return getProperty(str, obj.getClass()).getPropertyType();
+    }
+
+    protected PropertyDescriptor[] getSerializableProperties(Object obj) {
+        ArrayList arrayList = new ArrayList();
+        Iterator propertiesFor = this.propertyDictionary.propertiesFor(obj.getClass());
+        while (propertiesFor.hasNext()) {
+            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) propertiesFor.next();
+            if (canStreamProperty(propertyDescriptor)) {
+                arrayList.add(propertyDescriptor);
+            }
+        }
+        return (PropertyDescriptor[]) arrayList.toArray(new PropertyDescriptor[arrayList.size()]);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public Object newInstance(Class cls) {
+        ErrorWritingException objectAccessException;
+        try {
+            return cls.newInstance();
+        } catch (ExceptionInInitializerError e) {
+            objectAccessException = new ConversionException("Cannot construct type", e);
+            objectAccessException.add("construction-type", cls.getName());
+            throw objectAccessException;
+        } catch (IllegalAccessException e2) {
+            objectAccessException = new ObjectAccessException("Cannot construct type", e2);
+            objectAccessException.add("construction-type", cls.getName());
+            throw objectAccessException;
+        } catch (InstantiationException e3) {
+            objectAccessException = new ConversionException("Cannot construct type", e3);
+            objectAccessException.add("construction-type", cls.getName());
+            throw objectAccessException;
+        } catch (SecurityException e4) {
+            objectAccessException = new ObjectAccessException("Cannot construct type", e4);
+            objectAccessException.add("construction-type", cls.getName());
+            throw objectAccessException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public boolean propertyDefinedInClass(String str, Class cls) {
+        return this.propertyDictionary.propertyDescriptorOrNull(cls, str) != null;
+    }
+
+    public boolean propertyWriteable(String str, Class cls) {
+        return getProperty(str, cls).getWriteMethod() != null;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public void visitSerializableProperties(Object obj, JavaBeanProvider.Visitor visitor) {
+        ErrorWritingException conversionException;
+        for (PropertyDescriptor propertyDescriptor : getSerializableProperties(obj)) {
+            try {
+                Method readMethod = propertyDescriptor.getReadMethod();
+                String name = propertyDescriptor.getName();
+                Class<?> declaringClass = readMethod.getDeclaringClass();
+                if (visitor.shouldVisit(name, declaringClass)) {
+                    visitor.visit(name, propertyDescriptor.getPropertyType(), declaringClass, readMethod.invoke(obj, new Object[0]));
+                }
+                conversionException = null;
+            } catch (IllegalAccessException e) {
+                conversionException = new ObjectAccessException("Cannot access property", e);
+            } catch (IllegalArgumentException e2) {
+                conversionException = new ConversionException("Cannot get property", e2);
+            } catch (InvocationTargetException e3) {
+                conversionException = new ConversionException("Cannot get property", e3.getTargetException());
+            }
+            if (conversionException != null) {
+                StringBuffer stringBuffer = new StringBuffer();
+                stringBuffer.append(obj.getClass());
+                stringBuffer.append(".");
+                stringBuffer.append(propertyDescriptor.getName());
+                conversionException.add("property", stringBuffer.toString());
+                throw conversionException;
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider
+    public void writeProperty(Object obj, String str, Object obj2) {
+        ErrorWritingException conversionException;
+        PropertyDescriptor property = getProperty(str, obj.getClass());
+        try {
+            property.getWriteMethod().invoke(obj, obj2);
+            conversionException = null;
+        } catch (IllegalAccessException e) {
+            conversionException = new ObjectAccessException("Cannot access property", e);
+        } catch (IllegalArgumentException e2) {
+            conversionException = new ConversionException("Cannot set property", e2);
+        } catch (InvocationTargetException e3) {
+            conversionException = new ConversionException("Cannot set property", e3.getTargetException());
+        }
+        if (conversionException == null) {
+            return;
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(obj.getClass());
+        stringBuffer.append(".");
+        stringBuffer.append(property.getName());
+        conversionException.add("property", stringBuffer.toString());
+        throw conversionException;
+    }
+
+    public BeanProvider(Comparator comparator) {
+        this(new PropertyDictionary(new ComparingPropertySorter(comparator)));
+    }
+
+    public BeanProvider(PropertyDictionary propertyDictionary) {
+        this.propertyDictionary = propertyDictionary;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/ComparingPropertySorter.java

@@ -0,0 +1,21 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import java.util.Comparator;
+import java.util.Map;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class ComparingPropertySorter implements PropertySorter {
+    private final Comparator comparator;
+
+    public ComparingPropertySorter(Comparator comparator) {
+        this.comparator = comparator;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.javabean.PropertySorter
+    public Map sort(Class cls, Map map) {
+        TreeMap treeMap = new TreeMap(this.comparator);
+        treeMap.putAll(map);
+        return treeMap;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/JavaBeanConverter.java

@@ -0,0 +1,186 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+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.converters.javabean.JavaBeanProvider;
+import com.thoughtworks.xstream.converters.reflection.MissingFieldException;
+import com.thoughtworks.xstream.core.util.FastField;
+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.HashSet;
+
+/* loaded from: classes.dex */
+public class JavaBeanConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    protected final JavaBeanProvider beanProvider;
+    private String classAttributeIdentifier;
+    protected final Mapper mapper;
+    private final Class type;
+
+    public static class DuplicateFieldException extends ConversionException {
+        public DuplicateFieldException(String str) {
+            super(str);
+        }
+    }
+
+    public static class DuplicatePropertyException extends ConversionException {
+        /* 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 DuplicatePropertyException(java.lang.String r3) {
+            /*
+                r2 = this;
+                java.lang.StringBuffer r0 = new java.lang.StringBuffer
+                r0.<init>()
+                java.lang.String r1 = "Duplicate property "
+                r0.append(r1)
+                r0.append(r3)
+                java.lang.String r0 = r0.toString()
+                r2.<init>(r0)
+                java.lang.String r0 = "property"
+                r2.add(r0, r3)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.DuplicatePropertyException.<init>(java.lang.String):void");
+        }
+    }
+
+    public JavaBeanConverter(Mapper mapper) {
+        this(mapper, (Class) null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private Class determineType(HierarchicalStreamReader hierarchicalStreamReader, Object obj, String str) {
+        String str2 = this.classAttributeIdentifier;
+        if (str2 == null) {
+            str2 = this.mapper.aliasForSystemAttribute("class");
+        }
+        String attribute = str2 == null ? null : hierarchicalStreamReader.getAttribute(str2);
+        return attribute != null ? this.mapper.realClass(attribute) : this.mapper.defaultImplementationOf(this.beanProvider.getPropertyType(obj, str));
+    }
+
+    private Object instantiateNewInstance(UnmarshallingContext unmarshallingContext) {
+        Object currentObject = unmarshallingContext.currentObject();
+        return currentObject == null ? this.beanProvider.newInstance(unmarshallingContext.getRequiredType()) : currentObject;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = this.type;
+        return (cls2 == null || cls2 == cls) && this.beanProvider.canInstantiate(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(final Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, final MarshallingContext marshallingContext) {
+        final String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class");
+        this.beanProvider.visitSerializableProperties(obj, new JavaBeanProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.1
+            private void writeField(String str, Class cls, Object obj2) {
+                String str2;
+                Class<?> cls2 = obj2.getClass();
+                Class defaultImplementationOf = JavaBeanConverter.this.mapper.defaultImplementationOf(cls);
+                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, JavaBeanConverter.this.mapper.serializedMember(obj.getClass(), str), cls2);
+                if (!cls2.equals(defaultImplementationOf) && (str2 = aliasForSystemAttribute) != null) {
+                    hierarchicalStreamWriter.addAttribute(str2, JavaBeanConverter.this.mapper.serializedClass(cls2));
+                }
+                marshallingContext.convertAnother(obj2);
+                hierarchicalStreamWriter.endNode();
+            }
+
+            private void writeNullField(String str) {
+                String serializedMember = JavaBeanConverter.this.mapper.serializedMember(obj.getClass(), str);
+                HierarchicalStreamWriter hierarchicalStreamWriter2 = hierarchicalStreamWriter;
+                Class cls = JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null;
+                if (cls == null) {
+                    cls = JavaBeanConverter.class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                    JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+                }
+                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter2, serializedMember, cls);
+                HierarchicalStreamWriter hierarchicalStreamWriter3 = hierarchicalStreamWriter;
+                String str2 = aliasForSystemAttribute;
+                Mapper mapper = JavaBeanConverter.this.mapper;
+                Class cls2 = JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null;
+                if (cls2 == null) {
+                    cls2 = JavaBeanConverter.class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                    JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+                }
+                hierarchicalStreamWriter3.addAttribute(str2, mapper.serializedClass(cls2));
+                hierarchicalStreamWriter.endNode();
+            }
+
+            @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider.Visitor
+            public boolean shouldVisit(String str, Class cls) {
+                return JavaBeanConverter.this.mapper.shouldSerializeMember(cls, str);
+            }
+
+            @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider.Visitor
+            public void visit(String str, Class cls, Class cls2, Object obj2) {
+                if (obj2 != null) {
+                    writeField(str, cls, obj2);
+                } else {
+                    writeNullField(str);
+                }
+            }
+        });
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Object instantiateNewInstance = instantiateNewInstance(unmarshallingContext);
+        HashSet hashSet = new HashSet() { // from class: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.2
+            @Override // java.util.HashSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
+            public boolean add(Object obj) {
+                if (super.add(obj)) {
+                    return true;
+                }
+                throw new DuplicatePropertyException(((FastField) obj).getName());
+            }
+        };
+        Class<?> cls = instantiateNewInstance.getClass();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String realMember = this.mapper.realMember(cls, hierarchicalStreamReader.getNodeName());
+            if (this.mapper.shouldSerializeMember(cls, realMember)) {
+                if (this.beanProvider.propertyDefinedInClass(realMember, cls)) {
+                    this.beanProvider.writeProperty(instantiateNewInstance, realMember, unmarshallingContext.convertAnother(instantiateNewInstance, determineType(hierarchicalStreamReader, instantiateNewInstance, realMember)));
+                    hashSet.add(new FastField(cls, realMember));
+                } else if (!this.mapper.isIgnoredElement(realMember)) {
+                    throw new MissingFieldException(cls.getName(), realMember);
+                }
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        return instantiateNewInstance;
+    }
+
+    public JavaBeanConverter(Mapper mapper, Class cls) {
+        this(mapper, new BeanProvider(), cls);
+    }
+
+    public JavaBeanConverter(Mapper mapper, JavaBeanProvider javaBeanProvider) {
+        this(mapper, javaBeanProvider, null);
+    }
+
+    public JavaBeanConverter(Mapper mapper, JavaBeanProvider javaBeanProvider, Class cls) {
+        this.mapper = mapper;
+        this.beanProvider = javaBeanProvider;
+        this.type = cls;
+    }
+
+    public JavaBeanConverter(Mapper mapper, String str) {
+        this(mapper, new BeanProvider());
+        this.classAttributeIdentifier = str;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/JavaBeanProvider.java

@@ -0,0 +1,23 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+/* loaded from: classes.dex */
+public interface JavaBeanProvider {
+
+    public interface Visitor {
+        boolean shouldVisit(String str, Class cls);
+
+        void visit(String str, Class cls, Class cls2, Object obj);
+    }
+
+    boolean canInstantiate(Class cls);
+
+    Class getPropertyType(Object obj, String str);
+
+    Object newInstance(Class cls);
+
+    boolean propertyDefinedInClass(String str, Class cls);
+
+    void visitSerializableProperties(Object obj, Visitor visitor);
+
+    void writeProperty(Object obj, String str, Object obj2);
+}

sources/com/thoughtworks/xstream/converters/javabean/NativePropertySorter.java

@@ -0,0 +1,11 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class NativePropertySorter implements PropertySorter {
+    @Override // com.thoughtworks.xstream.converters.javabean.PropertySorter
+    public Map sort(Class cls, Map map) {
+        return map;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/PropertyDictionary.java

@@ -0,0 +1,109 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import com.thoughtworks.xstream.converters.reflection.MissingFieldException;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import com.thoughtworks.xstream.core.Caching;
+import com.thoughtworks.xstream.core.util.OrderRetainingMap;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class PropertyDictionary implements Caching {
+    static /* synthetic */ Class class$java$lang$Object;
+    private transient Map propertyNameCache;
+    private final PropertySorter sorter;
+
+    public PropertyDictionary() {
+        this(new NativePropertySorter());
+    }
+
+    private Map buildMap(Class cls) {
+        Class cls2;
+        Map map = (Map) this.propertyNameCache.get(cls);
+        if (map != null) {
+            return map;
+        }
+        try {
+            if (class$java$lang$Object == null) {
+                cls2 = class$("java.lang.Object");
+                class$java$lang$Object = cls2;
+            } else {
+                cls2 = class$java$lang$Object;
+            }
+            BeanInfo beanInfo = Introspector.getBeanInfo(cls, cls2);
+            OrderRetainingMap orderRetainingMap = new OrderRetainingMap();
+            for (PropertyDescriptor propertyDescriptor : beanInfo.getPropertyDescriptors()) {
+                orderRetainingMap.put(propertyDescriptor.getName(), propertyDescriptor);
+            }
+            Map sort = this.sorter.sort(cls, orderRetainingMap);
+            this.propertyNameCache.put(cls, sort);
+            return sort;
+        } catch (IntrospectionException e) {
+            ObjectAccessException objectAccessException = new ObjectAccessException("Cannot get BeanInfo of type", e);
+            objectAccessException.add("bean-type", cls.getName());
+            throw objectAccessException;
+        }
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.core.Caching
+    public void flushCache() {
+        this.propertyNameCache.clear();
+    }
+
+    public Iterator propertiesFor(Class cls) {
+        return buildMap(cls).values().iterator();
+    }
+
+    public BeanProperty property(Class cls, String str) {
+        PropertyDescriptor propertyDescriptorOrNull = propertyDescriptorOrNull(cls, str);
+        if (propertyDescriptorOrNull == null) {
+            throw new MissingFieldException(cls.getName(), str);
+        }
+        if (propertyDescriptorOrNull.getReadMethod() == null || propertyDescriptorOrNull.getWriteMethod() == null) {
+            return null;
+        }
+        return new BeanProperty(cls, propertyDescriptorOrNull.getName(), propertyDescriptorOrNull.getPropertyType());
+    }
+
+    public PropertyDescriptor propertyDescriptor(Class cls, String str) {
+        PropertyDescriptor propertyDescriptorOrNull = propertyDescriptorOrNull(cls, str);
+        if (propertyDescriptorOrNull != null) {
+            return propertyDescriptorOrNull;
+        }
+        throw new MissingFieldException(cls.getName(), str);
+    }
+
+    public PropertyDescriptor propertyDescriptorOrNull(Class cls, String str) {
+        return (PropertyDescriptor) buildMap(cls).get(str);
+    }
+
+    public Iterator serializablePropertiesFor(Class cls) {
+        ArrayList arrayList = new ArrayList();
+        for (PropertyDescriptor propertyDescriptor : buildMap(cls).values()) {
+            if (propertyDescriptor.getReadMethod() != null && propertyDescriptor.getWriteMethod() != null) {
+                arrayList.add(new BeanProperty(cls, propertyDescriptor.getName(), propertyDescriptor.getPropertyType()));
+            }
+        }
+        return arrayList.iterator();
+    }
+
+    public PropertyDictionary(PropertySorter propertySorter) {
+        this.propertyNameCache = Collections.synchronizedMap(new HashMap());
+        this.sorter = propertySorter;
+    }
+}

sources/com/thoughtworks/xstream/converters/javabean/PropertySorter.java

@@ -0,0 +1,8 @@
+package com.thoughtworks.xstream.converters.javabean;
+
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public interface PropertySorter {
+    Map sort(Class cls, Map map);
+}

sources/com/thoughtworks/xstream/converters/reflection/AbstractAttributedCharacterIteratorAttributeConverter.java

@@ -0,0 +1,175 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import com.thoughtworks.xstream.core.util.Fields;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.text.AttributedCharacterIterator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class AbstractAttributedCharacterIteratorAttributeConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$String;
+    static /* synthetic */ Class class$java$text$AttributedCharacterIterator$Attribute;
+    static /* synthetic */ Class class$java$util$Map;
+    private static final Method getName;
+    private static final Map instanceMaps = new HashMap();
+    private transient Map attributeMap;
+    private final Class type;
+
+    static {
+        Class cls;
+        Method method = null;
+        try {
+            if (class$java$text$AttributedCharacterIterator$Attribute == null) {
+                cls = class$("java.text.AttributedCharacterIterator$Attribute");
+                class$java$text$AttributedCharacterIterator$Attribute = cls;
+            } else {
+                cls = class$java$text$AttributedCharacterIterator$Attribute;
+            }
+            method = cls.getDeclaredMethod("getName", null);
+            if (!method.isAccessible()) {
+                method.setAccessible(true);
+            }
+        } catch (NoSuchMethodException | SecurityException unused) {
+        }
+        getName = method;
+    }
+
+    public AbstractAttributedCharacterIteratorAttributeConverter(Class cls) {
+        Class cls2 = class$java$text$AttributedCharacterIterator$Attribute;
+        if (cls2 == null) {
+            cls2 = class$("java.text.AttributedCharacterIterator$Attribute");
+            class$java$text$AttributedCharacterIterator$Attribute = cls2;
+        }
+        if (cls2.isAssignableFrom(cls)) {
+            this.type = cls;
+            readResolve();
+            return;
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(cls.getName());
+        stringBuffer.append(" is not a ");
+        Class cls3 = class$java$text$AttributedCharacterIterator$Attribute;
+        if (cls3 == null) {
+            cls3 = class$("java.text.AttributedCharacterIterator$Attribute");
+            class$java$text$AttributedCharacterIterator$Attribute = cls3;
+        }
+        stringBuffer.append(cls3.getName());
+        throw new IllegalArgumentException(stringBuffer.toString());
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private String getName(AttributedCharacterIterator.Attribute attribute) {
+        Method method = getName;
+        Throwable th = null;
+        if (method != null) {
+            try {
+                return (String) method.invoke(attribute, null);
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                th = e;
+            }
+        }
+        String attribute2 = attribute.toString();
+        String name = attribute.getClass().getName();
+        if (attribute2.startsWith(name)) {
+            return attribute2.substring(name.length() + 1, attribute2.length() - 1);
+        }
+        ConversionException conversionException = new ConversionException("Cannot find name of attribute", th);
+        conversionException.add("attribute-type", name);
+        throw conversionException;
+    }
+
+    private Object readResolve() {
+        boolean z;
+        Class<?> cls;
+        this.attributeMap = (Map) instanceMaps.get(this.type.getName());
+        if (this.attributeMap == null) {
+            this.attributeMap = new HashMap();
+            Class cls2 = this.type;
+            Class cls3 = class$java$util$Map;
+            if (cls3 == null) {
+                cls3 = class$("java.util.Map");
+                class$java$util$Map = cls3;
+            }
+            Field locate = Fields.locate(cls2, cls3, true);
+            if (locate != null) {
+                try {
+                    Map map = (Map) Fields.read(locate, null);
+                    if (map != null) {
+                        Iterator it = map.entrySet().iterator();
+                        loop1: while (true) {
+                            while (z && it.hasNext()) {
+                                Map.Entry entry = (Map.Entry) it.next();
+                                Class<?> cls4 = entry.getKey().getClass();
+                                if (class$java$lang$String == null) {
+                                    cls = class$("java.lang.String");
+                                    class$java$lang$String = cls;
+                                } else {
+                                    cls = class$java$lang$String;
+                                }
+                                z = cls4 == cls && entry.getValue().getClass() == this.type;
+                            }
+                        }
+                        if (z) {
+                            this.attributeMap.putAll(map);
+                        }
+                    }
+                } catch (ObjectAccessException unused) {
+                }
+            }
+            if (this.attributeMap.isEmpty()) {
+                try {
+                    Field[] declaredFields = this.type.getDeclaredFields();
+                    for (int i = 0; i < declaredFields.length; i++) {
+                        if ((declaredFields[i].getType() == this.type) == Modifier.isStatic(declaredFields[i].getModifiers())) {
+                            AttributedCharacterIterator.Attribute attribute = (AttributedCharacterIterator.Attribute) Fields.read(declaredFields[i], null);
+                            this.attributeMap.put(toString(attribute), attribute);
+                        }
+                    }
+                } catch (ObjectAccessException unused2) {
+                    this.attributeMap.clear();
+                } catch (NoClassDefFoundError unused3) {
+                    this.attributeMap.clear();
+                } catch (SecurityException unused4) {
+                    this.attributeMap.clear();
+                }
+            }
+            instanceMaps.put(this.type.getName(), this.attributeMap);
+        }
+        return this;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls == this.type && !this.attributeMap.isEmpty();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        if (this.attributeMap.containsKey(str)) {
+            return this.attributeMap.get(str);
+        }
+        ConversionException conversionException = new ConversionException("Cannot find attribute");
+        conversionException.add("attribute-type", this.type.getName());
+        conversionException.add("attribute-name", str);
+        throw conversionException;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return getName((AttributedCharacterIterator.Attribute) obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/AbstractReflectionConverter.java

@@ -0,0 +1,383 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+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.Caching;
+import com.thoughtworks.xstream.core.ReferencingMarshallingContext;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.core.util.SerializationMembers;
+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.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class AbstractReflectionConverter implements Converter, Caching {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    static /* synthetic */ Class class$java$lang$Object;
+    static /* synthetic */ Class class$java$util$Collection;
+    static /* synthetic */ Class class$java$util$Map;
+    static /* synthetic */ Class class$java$util$Map$Entry;
+    protected final Mapper mapper;
+    private transient ReflectionProvider pureJavaReflectionProvider;
+    protected final ReflectionProvider reflectionProvider;
+    protected transient SerializationMethodInvoker serializationMethodInvoker = new SerializationMethodInvoker();
+    protected transient SerializationMembers serializationMembers = this.serializationMethodInvoker.serializationMembers;
+
+    private static class ArraysList extends ArrayList {
+        final Class physicalFieldType;
+
+        ArraysList(Class cls) {
+            this.physicalFieldType = cls;
+        }
+
+        Object toPhysicalArray() {
+            Object[] array = toArray();
+            Object newInstance = Array.newInstance(this.physicalFieldType.getComponentType(), array.length);
+            if (this.physicalFieldType.getComponentType().isPrimitive()) {
+                for (int i = 0; i < array.length; i++) {
+                    Array.set(newInstance, i, Array.get(array, i));
+                }
+            } else {
+                System.arraycopy(array, 0, newInstance, 0, array.length);
+            }
+            return newInstance;
+        }
+    }
+
+    public static class DuplicateFieldException extends ConversionException {
+        /* 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 DuplicateFieldException(java.lang.String r3) {
+            /*
+                r2 = this;
+                java.lang.StringBuffer r0 = new java.lang.StringBuffer
+                r0.<init>()
+                java.lang.String r1 = "Duplicate field "
+                r0.append(r1)
+                r0.append(r3)
+                java.lang.String r0 = r0.toString()
+                r2.<init>(r0)
+                java.lang.String r0 = "field"
+                r2.add(r0, r3)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.DuplicateFieldException.<init>(java.lang.String):void");
+        }
+    }
+
+    private static class FieldInfo extends FieldLocation {
+        final Class type;
+        final Object value;
+
+        FieldInfo(String str, Class cls, Class cls2, Object obj) {
+            super(str, cls2);
+            this.type = cls;
+            this.value = obj;
+        }
+    }
+
+    private static class FieldLocation {
+        final Class definedIn;
+        final String fieldName;
+
+        FieldLocation(String str, Class cls) {
+            this.fieldName = str;
+            this.definedIn = cls;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || getClass() != obj.getClass()) {
+                return false;
+            }
+            FieldLocation fieldLocation = (FieldLocation) obj;
+            if (this.definedIn != fieldLocation.definedIn) {
+                return false;
+            }
+            String str = this.fieldName;
+            if (str == null) {
+                if (fieldLocation.fieldName != null) {
+                    return false;
+                }
+            } else if (!str.equals(fieldLocation.fieldName)) {
+                return false;
+            }
+            return true;
+        }
+
+        public int hashCode() {
+            Class cls = this.definedIn;
+            int hashCode = ((cls == null ? 0 : cls.getName().hashCode()) + 7) * 7;
+            String str = this.fieldName;
+            return hashCode + (str != null ? str.hashCode() : 0);
+        }
+    }
+
+    private interface FieldMarshaller {
+        void writeField(String str, String str2, Class cls, Class cls2, Object obj);
+
+        void writeItem(Object obj);
+    }
+
+    private class MappingList extends AbstractList {
+        private final Map fieldCache = new HashMap();
+        private final String keyFieldName;
+        private final Map map;
+
+        public MappingList(Map map, String str) {
+            this.map = map;
+            this.keyFieldName = str;
+        }
+
+        @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+        public boolean add(Object obj) {
+            if (obj == null) {
+                boolean z = !this.map.containsKey(null);
+                this.map.put(null, null);
+                return z;
+            }
+            Class<?> cls = obj.getClass();
+            if (this.keyFieldName != null) {
+                Field field = (Field) this.fieldCache.get(cls);
+                if (field == null) {
+                    field = AbstractReflectionConverter.this.reflectionProvider.getField(cls, this.keyFieldName);
+                    this.fieldCache.put(cls, field);
+                }
+                if (field != null) {
+                    return this.map.put(Fields.read(field, obj), obj) == null;
+                }
+            } else if (obj instanceof Map.Entry) {
+                Map.Entry entry = (Map.Entry) obj;
+                return this.map.put(entry.getKey(), entry.getValue()) == null;
+            }
+            ConversionException conversionException = new ConversionException("Element  is not defined as entry for implicit map");
+            conversionException.add("map-type", this.map.getClass().getName());
+            conversionException.add("element-type", obj.getClass().getName());
+            throw conversionException;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public Object get(int i) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public int size() {
+            return this.map.size();
+        }
+    }
+
+    public static class UnknownFieldException extends ConversionException {
+        /* 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 UnknownFieldException(java.lang.String r3, java.lang.String r4) {
+            /*
+                r2 = this;
+                java.lang.StringBuffer r0 = new java.lang.StringBuffer
+                r0.<init>()
+                java.lang.String r1 = "No such field "
+                r0.append(r1)
+                r0.append(r3)
+                java.lang.String r3 = "."
+                r0.append(r3)
+                r0.append(r4)
+                java.lang.String r3 = r0.toString()
+                r2.<init>(r3)
+                java.lang.String r3 = "field"
+                r2.add(r3, r4)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.UnknownFieldException.<init>(java.lang.String, java.lang.String):void");
+        }
+    }
+
+    public AbstractReflectionConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
+        this.mapper = mapper;
+        this.reflectionProvider = reflectionProvider;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private void handleUnknownField(Class cls, String str, Class cls2, String str2) {
+        if (cls == null) {
+            for (Class cls3 = cls2; cls3 != null; cls3 = cls3.getSuperclass()) {
+                if (!this.mapper.shouldSerializeMember(cls3, str2)) {
+                    return;
+                }
+            }
+        }
+        throw new UnknownFieldException(cls2.getName(), str);
+    }
+
+    private Class readDeclaringClass(HierarchicalStreamReader hierarchicalStreamReader) {
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("defined-in");
+        String attribute = aliasForSystemAttribute == null ? null : hierarchicalStreamReader.getAttribute(aliasForSystemAttribute);
+        if (attribute == null) {
+            return null;
+        }
+        return this.mapper.realClass(attribute);
+    }
+
+    private void writeValueToImplicitCollection(Object obj, Map map, Object obj2, FieldLocation fieldLocation) {
+        Collection collection = (Collection) map.get(fieldLocation);
+        if (collection == null) {
+            Field fieldOrNull = this.reflectionProvider.getFieldOrNull(fieldLocation.definedIn, fieldLocation.fieldName);
+            Class type = fieldOrNull != null ? fieldOrNull.getType() : this.reflectionProvider.getFieldType(obj2, fieldLocation.fieldName, null);
+            if (type.isArray()) {
+                collection = new ArraysList(type);
+            } else {
+                Class<?> defaultImplementationOf = this.mapper.defaultImplementationOf(type);
+                Class cls = class$java$util$Collection;
+                if (cls == null) {
+                    cls = class$("java.util.Collection");
+                    class$java$util$Collection = cls;
+                }
+                if (!cls.isAssignableFrom(defaultImplementationOf)) {
+                    Class cls2 = class$java$util$Map;
+                    if (cls2 == null) {
+                        cls2 = class$("java.util.Map");
+                        class$java$util$Map = cls2;
+                    }
+                    if (!cls2.isAssignableFrom(defaultImplementationOf)) {
+                        ObjectAccessException objectAccessException = new ObjectAccessException("Field is configured for an implicit Collection or Map, but is of an incompatible type");
+                        StringBuffer stringBuffer = new StringBuffer();
+                        stringBuffer.append(obj2.getClass().getName());
+                        stringBuffer.append(".");
+                        stringBuffer.append(fieldLocation.fieldName);
+                        objectAccessException.add("field", stringBuffer.toString());
+                        objectAccessException.add("field-type", defaultImplementationOf.getName());
+                        throw objectAccessException;
+                    }
+                }
+                if (this.pureJavaReflectionProvider == null) {
+                    this.pureJavaReflectionProvider = new PureJavaReflectionProvider();
+                }
+                Object newInstance = this.pureJavaReflectionProvider.newInstance(defaultImplementationOf);
+                Collection mappingList = newInstance instanceof Collection ? (Collection) newInstance : new MappingList((Map) newInstance, this.mapper.getImplicitCollectionDefForFieldName(fieldLocation.definedIn, fieldLocation.fieldName).getKeyFieldName());
+                this.reflectionProvider.writeField(obj2, fieldLocation.fieldName, newInstance, fieldOrNull != null ? fieldOrNull.getDeclaringClass() : null);
+                collection = mappingList;
+            }
+            map.put(fieldLocation, collection);
+        }
+        collection.add(obj);
+    }
+
+    protected boolean canAccess(Class cls) {
+        try {
+            this.reflectionProvider.getFieldOrNull(cls, "%");
+            return true;
+        } catch (NoClassDefFoundError unused) {
+            return false;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x017f A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x008d A[SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    protected void doMarshal(final java.lang.Object r20, final com.thoughtworks.xstream.io.HierarchicalStreamWriter r21, final com.thoughtworks.xstream.converters.MarshallingContext r22) {
+        /*
+            Method dump skipped, instructions count: 399
+            To view this dump change 'Code comments level' option to 'DEBUG'
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.doMarshal(java.lang.Object, com.thoughtworks.xstream.io.HierarchicalStreamWriter, com.thoughtworks.xstream.converters.MarshallingContext):void");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:51:0x0100  */
+    /* JADX WARN: Removed duplicated region for block: B:59:0x0218  */
+    /* JADX WARN: Removed duplicated region for block: B:62:0x022e  */
+    /* JADX WARN: Removed duplicated region for block: B:76:0x0103  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public java.lang.Object doUnmarshal(java.lang.Object r13, com.thoughtworks.xstream.io.HierarchicalStreamReader r14, com.thoughtworks.xstream.converters.UnmarshallingContext r15) {
+        /*
+            Method dump skipped, instructions count: 676
+            To view this dump change 'Code comments level' option to 'DEBUG'
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.doUnmarshal(java.lang.Object, com.thoughtworks.xstream.io.HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext):java.lang.Object");
+    }
+
+    @Override // com.thoughtworks.xstream.core.Caching
+    public void flushCache() {
+        this.serializationMethodInvoker.flushCache();
+    }
+
+    protected Object instantiateNewInstance(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("resolves-to");
+        String attribute = aliasForSystemAttribute == null ? null : hierarchicalStreamReader.getAttribute(aliasForSystemAttribute);
+        Object currentObject = unmarshallingContext.currentObject();
+        return currentObject != null ? currentObject : attribute != null ? this.reflectionProvider.newInstance(this.mapper.realClass(attribute)) : this.reflectionProvider.newInstance(unmarshallingContext.getRequiredType());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Object callWriteReplace = this.serializationMembers.callWriteReplace(obj);
+        if (callWriteReplace != obj && (marshallingContext instanceof ReferencingMarshallingContext)) {
+            ((ReferencingMarshallingContext) marshallingContext).replace(obj, callWriteReplace);
+        }
+        if (callWriteReplace.getClass() == obj.getClass()) {
+            doMarshal(callWriteReplace, hierarchicalStreamWriter, marshallingContext);
+            return;
+        }
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("resolves-to");
+        if (aliasForSystemAttribute != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(callWriteReplace.getClass()));
+        }
+        marshallingContext.convertAnother(callWriteReplace);
+    }
+
+    protected void marshallField(MarshallingContext marshallingContext, Object obj, Field field) {
+        marshallingContext.convertAnother(obj, this.mapper.getLocalConverter(field.getDeclaringClass(), field.getName()));
+    }
+
+    protected Object readResolve() {
+        this.serializationMethodInvoker = new SerializationMethodInvoker();
+        this.serializationMembers = this.serializationMethodInvoker.serializationMembers;
+        return this;
+    }
+
+    protected boolean shouldUnmarshalField(Field field) {
+        return !Modifier.isTransient(field.getModifiers()) || shouldUnmarshalTransientFields();
+    }
+
+    protected boolean shouldUnmarshalTransientFields() {
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return this.serializationMembers.callReadResolve(doUnmarshal(instantiateNewInstance(hierarchicalStreamReader, unmarshallingContext), hierarchicalStreamReader, unmarshallingContext));
+    }
+
+    protected Object unmarshallField(UnmarshallingContext unmarshallingContext, Object obj, Class cls, Field field) {
+        return unmarshallingContext.convertAnother(obj, cls, this.mapper.getLocalConverter(field.getDeclaringClass(), field.getName()));
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/CGLIBEnhancedConverter.java

@@ -0,0 +1,564 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import com.ijm.dataencryption.de.DataDecryptTool;
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
+import com.thoughtworks.xstream.core.ClassLoaderReference;
+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.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import net.sf.cglib.proxy.Callback;
+import net.sf.cglib.proxy.CallbackFilter;
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.Factory;
+import net.sf.cglib.proxy.NoOp;
+
+/* loaded from: classes.dex */
+public class CGLIBEnhancedConverter extends SerializableConverter {
+    private static String CALLBACK_MARKER = "CGLIB$CALLBACK_";
+    private static String DEFAULT_NAMING_MARKER = "$$EnhancerByCGLIB$$";
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker;
+    static /* synthetic */ Class class$java$lang$Class;
+    static /* synthetic */ Class class$java$lang$String;
+    static /* synthetic */ Class class$java$util$HashMap;
+    static /* synthetic */ Class class$net$sf$cglib$proxy$Callback;
+    static /* synthetic */ Class class$net$sf$cglib$proxy$Factory;
+    static /* synthetic */ Class class$net$sf$cglib$proxy$MethodInterceptor;
+    static /* synthetic */ Class class$net$sf$cglib$proxy$NoOp;
+    private transient Map fieldCache;
+
+    private static class CGLIBFilteringReflectionProvider extends ReflectionProviderWrapper {
+        public CGLIBFilteringReflectionProvider(ReflectionProvider reflectionProvider) {
+            super(reflectionProvider);
+        }
+
+        @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProviderWrapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider
+        public void visitSerializableFields(Object obj, final ReflectionProvider.Visitor visitor) {
+            this.wrapped.visitSerializableFields(obj, new ReflectionProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.CGLIBFilteringReflectionProvider.1
+                @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor
+                public void visit(String str, Class cls, Class cls2, Object obj2) {
+                    if (str.startsWith("CGLIB$")) {
+                        return;
+                    }
+                    visitor.visit(str, cls, cls2, obj2);
+                }
+            });
+        }
+    }
+
+    private static class ReverseEngineeredCallbackFilter implements CallbackFilter {
+        private final Map callbackIndexMap;
+
+        public ReverseEngineeredCallbackFilter(Map map) {
+            this.callbackIndexMap = map;
+        }
+
+        public int accept(Method method) {
+            if (this.callbackIndexMap.containsKey(method)) {
+                return ((Integer) this.callbackIndexMap.get(method)).intValue();
+            }
+            ConversionException conversionException = new ConversionException("CGLIB callback not detected in reverse engineering");
+            conversionException.add("CGLIB-callback", method.toString());
+            throw conversionException;
+        }
+    }
+
+    private static final class ReverseEngineeringInvocationHandler implements InvocationHandler {
+        private final Integer index;
+        private final Map indexMap;
+
+        public ReverseEngineeringInvocationHandler(int i, Map map) {
+            this.indexMap = map;
+            this.index = new Integer(i);
+        }
+
+        @Override // java.lang.reflect.InvocationHandler
+        public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+            Map map = this.indexMap;
+            map.put(map.get(null), this.index);
+            return null;
+        }
+    }
+
+    public CGLIBEnhancedConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
+        super(mapper, new CGLIBFilteringReflectionProvider(reflectionProvider), classLoaderReference);
+        this.fieldCache = new HashMap();
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private Object create(Enhancer enhancer, List list, boolean z) {
+        Object create = enhancer.create();
+        if (z) {
+            ((Factory) create).setCallbacks((Callback[]) list.toArray(new Callback[list.size()]));
+        }
+        return create;
+    }
+
+    private Map createCallbackIndexMap(Factory factory) {
+        Class cls;
+        Method method;
+        Callback[] callbacks = factory.getCallbacks();
+        Callback[] callbackArr = new Callback[callbacks.length];
+        Map hashMap = new HashMap();
+        int i = -1;
+        for (int i2 = 0; i2 < callbacks.length; i2++) {
+            Callback callback = callbacks[i2];
+            if (callback == null) {
+                callbackArr[i2] = null;
+            } else {
+                Class cls2 = class$net$sf$cglib$proxy$NoOp;
+                if (cls2 == null) {
+                    cls2 = class$("net.sf.cglib.proxy.NoOp");
+                    class$net$sf$cglib$proxy$NoOp = cls2;
+                }
+                if (cls2.isAssignableFrom(callback.getClass())) {
+                    callbackArr[i2] = NoOp.INSTANCE;
+                    i = i2;
+                } else {
+                    callbackArr[i2] = createReverseEngineeredCallbackOfProperType(callback, i2, hashMap);
+                }
+            }
+        }
+        try {
+            factory.setCallbacks(callbackArr);
+            HashSet<Class<?>> hashSet = new HashSet();
+            HashSet hashSet2 = new HashSet();
+            r6 = factory.getClass();
+            do {
+                hashSet2.addAll(Arrays.asList(r6.getDeclaredMethods()));
+                hashSet2.addAll(Arrays.asList(r6.getMethods()));
+                hashSet.addAll(Arrays.asList(r6.getInterfaces()));
+                r6 = r6.getSuperclass();
+            } while (r6 != null);
+            for (Class<?> cls3 : hashSet) {
+                hashSet2.addAll(Arrays.asList(cls3.getDeclaredMethods()));
+            }
+            Iterator it = hashSet2.iterator();
+            while (it.hasNext()) {
+                Method method2 = (Method) it.next();
+                if (!method2.isAccessible()) {
+                    method2.setAccessible(true);
+                }
+                if (class$net$sf$cglib$proxy$Factory == null) {
+                    cls = class$("net.sf.cglib.proxy.Factory");
+                    class$net$sf$cglib$proxy$Factory = cls;
+                } else {
+                    cls = class$net$sf$cglib$proxy$Factory;
+                }
+                if (!cls.isAssignableFrom(method2.getDeclaringClass()) && (method2.getModifiers() & 24) <= 0) {
+                    Class[] parameterTypes = method2.getParameterTypes();
+                    try {
+                        try {
+                            method = (method2.getModifiers() & DataDecryptTool.DECRYPT_SP_FILE) > 0 ? factory.getClass().getMethod(method2.getName(), method2.getParameterTypes()) : method2;
+                        } catch (NoSuchMethodException unused) {
+                            ConversionException conversionException = new ConversionException("CGLIB enhanced proxies wit abstract nethod that has not been implemented");
+                            conversionException.add("proxy-superclass", cls3.getSuperclass().getName());
+                            conversionException.add("method", method2.toString());
+                            throw conversionException;
+                        } catch (InvocationTargetException unused2) {
+                        }
+                    } catch (IllegalAccessException e) {
+                        e = e;
+                    }
+                    try {
+                        hashMap.put(null, method2);
+                        method.invoke(factory, parameterTypes == null ? null : createNullArguments(parameterTypes));
+                        if (hashMap.containsKey(method2)) {
+                            it.remove();
+                        }
+                    } catch (IllegalAccessException e2) {
+                        e = e2;
+                        method2 = method;
+                        ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access method", e);
+                        objectAccessException.add("method", method2.toString());
+                        throw objectAccessException;
+                    }
+                }
+                it.remove();
+            }
+            if (i >= 0) {
+                Integer num = new Integer(i);
+                Iterator it2 = hashSet2.iterator();
+                while (it2.hasNext()) {
+                    hashMap.put(it2.next(), num);
+                }
+            }
+            factory.setCallbacks(callbacks);
+            hashMap.remove(null);
+            return hashMap;
+        } catch (Throwable th) {
+            factory.setCallbacks(callbacks);
+            throw th;
+        }
+    }
+
+    private Object[] createNullArguments(Class[] clsArr) {
+        Object[] objArr = new Object[clsArr.length];
+        for (int i = 0; i < objArr.length; i++) {
+            Class cls = clsArr[i];
+            if (cls.isPrimitive()) {
+                if (cls == Byte.TYPE) {
+                    objArr[i] = new Byte((byte) 0);
+                } else if (cls == Short.TYPE) {
+                    objArr[i] = new Short((short) 0);
+                } else if (cls == Integer.TYPE) {
+                    objArr[i] = new Integer(0);
+                } else if (cls == Long.TYPE) {
+                    objArr[i] = new Long(0L);
+                } else if (cls == Float.TYPE) {
+                    objArr[i] = new Float(0.0f);
+                } else if (cls == Double.TYPE) {
+                    objArr[i] = new Double(0.0d);
+                } else if (cls == Character.TYPE) {
+                    objArr[i] = new Character((char) 0);
+                } else {
+                    objArr[i] = Boolean.FALSE;
+                }
+            }
+        }
+        return objArr;
+    }
+
+    private Callback createReverseEngineeredCallbackOfProperType(Callback callback, int i, Map map) {
+        Class<?> cls = null;
+        Class<?>[] interfaces = callback.getClass().getInterfaces();
+        int i2 = 0;
+        while (i2 < interfaces.length) {
+            Class cls2 = class$net$sf$cglib$proxy$Callback;
+            if (cls2 == null) {
+                cls2 = class$("net.sf.cglib.proxy.Callback");
+                class$net$sf$cglib$proxy$Callback = cls2;
+            }
+            if (cls2.isAssignableFrom(interfaces[i2])) {
+                cls = interfaces[i2];
+                Class<?> cls3 = class$net$sf$cglib$proxy$Callback;
+                if (cls3 == null) {
+                    cls3 = class$("net.sf.cglib.proxy.Callback");
+                    class$net$sf$cglib$proxy$Callback = cls3;
+                }
+                if (cls == cls3) {
+                    ConversionException conversionException = new ConversionException("Cannot handle CGLIB callback");
+                    conversionException.add("CGLIB-callback-type", callback.getClass().getName());
+                    throw conversionException;
+                }
+                Class<?>[] interfaces2 = cls.getInterfaces();
+                List asList = Arrays.asList(interfaces2);
+                Class cls4 = class$net$sf$cglib$proxy$Callback;
+                if (cls4 == null) {
+                    cls4 = class$("net.sf.cglib.proxy.Callback");
+                    class$net$sf$cglib$proxy$Callback = cls4;
+                }
+                if (asList.contains(cls4)) {
+                    break;
+                }
+                interfaces = interfaces2;
+                i2 = -1;
+            }
+            i2++;
+        }
+        return (Callback) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new ReverseEngineeringInvocationHandler(i, map));
+    }
+
+    private Callback[] getCallbacks(Object obj) {
+        Class<?> cls = obj.getClass();
+        List list = (List) this.fieldCache.get(cls.getName());
+        if (list == null) {
+            list = new ArrayList();
+            this.fieldCache.put(cls.getName(), list);
+            int i = 0;
+            while (true) {
+                try {
+                    StringBuffer stringBuffer = new StringBuffer();
+                    stringBuffer.append(CALLBACK_MARKER);
+                    stringBuffer.append(i);
+                    Field declaredField = cls.getDeclaredField(stringBuffer.toString());
+                    if (!declaredField.isAccessible()) {
+                        declaredField.setAccessible(true);
+                    }
+                    list.add(declaredField);
+                    i++;
+                } catch (NoSuchFieldException unused) {
+                }
+            }
+        }
+        ArrayList arrayList = new ArrayList();
+        for (int i2 = 0; i2 < list.size(); i2++) {
+            try {
+                arrayList.add(((Field) list.get(i2)).get(obj));
+            } catch (IllegalAccessException e) {
+                ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access field", e);
+                StringBuffer stringBuffer2 = new StringBuffer();
+                stringBuffer2.append(cls.getName());
+                stringBuffer2.append(".");
+                stringBuffer2.append(CALLBACK_MARKER);
+                stringBuffer2.append(i2);
+                objectAccessException.add("field", stringBuffer2.toString());
+                throw objectAccessException;
+            }
+        }
+        return (Callback[]) arrayList.toArray(new Callback[arrayList.size()]);
+    }
+
+    private void readCallback(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, List list, List list2) {
+        Callback callback = (Callback) unmarshallingContext.convertAnother(null, this.mapper.realClass(hierarchicalStreamReader.getNodeName()));
+        list2.add(callback);
+        if (callback == null) {
+            list.add(NoOp.INSTANCE);
+        } else {
+            list.add(callback);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.SerializableConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls == null || !Enhancer.isEnhanced(cls) || cls.getName().indexOf(DEFAULT_NAMING_MARKER) <= 0) {
+            Class cls2 = class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.CGLIBMapper$Marker");
+                class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.SerializableConverter
+    protected List hierarchyFor(Class cls) {
+        List hierarchyFor = super.hierarchyFor(cls);
+        hierarchyFor.remove(hierarchyFor.size() - 1);
+        return hierarchyFor;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Class cls;
+        Class<?> cls2 = obj.getClass();
+        Class cls3 = class$net$sf$cglib$proxy$Factory;
+        if (cls3 == null) {
+            cls3 = class$("net.sf.cglib.proxy.Factory");
+            class$net$sf$cglib$proxy$Factory = cls3;
+        }
+        boolean isAssignableFrom = cls3.isAssignableFrom(cls2);
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "type", cls2);
+        marshallingContext.convertAnother(cls2.getSuperclass());
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("interfaces");
+        Class<?>[] interfaces = cls2.getInterfaces();
+        for (int i = 0; i < interfaces.length; i++) {
+            Class<?> cls4 = interfaces[i];
+            Class<?> cls5 = class$net$sf$cglib$proxy$Factory;
+            if (cls5 == null) {
+                cls5 = class$("net.sf.cglib.proxy.Factory");
+                class$net$sf$cglib$proxy$Factory = cls5;
+            }
+            if (cls4 != cls5) {
+                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(interfaces[i].getClass()), interfaces[i].getClass());
+                marshallingContext.convertAnother(interfaces[i]);
+                hierarchicalStreamWriter.endNode();
+            }
+        }
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("hasFactory");
+        hierarchicalStreamWriter.setValue(String.valueOf(isAssignableFrom));
+        hierarchicalStreamWriter.endNode();
+        Callback[] callbacks = isAssignableFrom ? ((Factory) obj).getCallbacks() : getCallbacks(obj);
+        if (callbacks.length > 1) {
+            if (!isAssignableFrom) {
+                ConversionException conversionException = new ConversionException("Cannot handle CGLIB enhanced proxies without factory that have multiple callbacks");
+                conversionException.add("proxy-superclass", cls2.getSuperclass().getName());
+                conversionException.add("number-of-callbacks", String.valueOf(callbacks.length));
+                throw conversionException;
+            }
+            Map createCallbackIndexMap = createCallbackIndexMap((Factory) obj);
+            hierarchicalStreamWriter.startNode("callbacks");
+            hierarchicalStreamWriter.startNode("mapping");
+            marshallingContext.convertAnother(createCallbackIndexMap);
+            hierarchicalStreamWriter.endNode();
+        }
+        boolean z = false;
+        for (Callback callback : callbacks) {
+            if (callback == null) {
+                hierarchicalStreamWriter.startNode(this.mapper.serializedClass(null));
+                hierarchicalStreamWriter.endNode();
+            } else {
+                if (!z) {
+                    Class cls6 = class$net$sf$cglib$proxy$MethodInterceptor;
+                    if (cls6 == null) {
+                        cls6 = class$("net.sf.cglib.proxy.MethodInterceptor");
+                        class$net$sf$cglib$proxy$MethodInterceptor = cls6;
+                    }
+                    if (!cls6.isAssignableFrom(callback.getClass())) {
+                        z = false;
+                        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(callback.getClass()), callback.getClass());
+                        marshallingContext.convertAnother(callback);
+                        hierarchicalStreamWriter.endNode();
+                    }
+                }
+                z = true;
+                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(callback.getClass()), callback.getClass());
+                marshallingContext.convertAnother(callback);
+                hierarchicalStreamWriter.endNode();
+            }
+        }
+        if (callbacks.length > 1) {
+            hierarchicalStreamWriter.endNode();
+        }
+        try {
+            Field declaredField = cls2.getDeclaredField("serialVersionUID");
+            if (!declaredField.isAccessible()) {
+                declaredField.setAccessible(true);
+            }
+            long j = declaredField.getLong(null);
+            if (class$java$lang$String == null) {
+                cls = class$("java.lang.String");
+                class$java$lang$String = cls;
+            } else {
+                cls = class$java$lang$String;
+            }
+            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "serialVersionUID", cls);
+            hierarchicalStreamWriter.setValue(String.valueOf(j));
+            hierarchicalStreamWriter.endNode();
+        } catch (IllegalAccessException e) {
+            ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access field", e);
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(cls2.getName());
+            stringBuffer.append(".serialVersionUID");
+            objectAccessException.add("field", stringBuffer.toString());
+            throw objectAccessException;
+        } catch (NoSuchFieldException unused) {
+        }
+        if (z) {
+            hierarchicalStreamWriter.startNode("instance");
+            super.doMarshalConditionally(obj, hierarchicalStreamWriter, marshallingContext);
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
+    protected Object readResolve() {
+        super.readResolve();
+        this.fieldCache = new HashMap();
+        return this;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Map map;
+        Enhancer enhancer = new Enhancer();
+        hierarchicalStreamReader.moveDown();
+        Class cls = class$java$lang$Class;
+        if (cls == null) {
+            cls = class$("java.lang.Class");
+            class$java$lang$Class = cls;
+        }
+        Object obj = null;
+        enhancer.setSuperclass((Class) unmarshallingContext.convertAnother(null, cls));
+        hierarchicalStreamReader.moveUp();
+        hierarchicalStreamReader.moveDown();
+        ArrayList arrayList = new ArrayList();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            arrayList.add(unmarshallingContext.convertAnother(null, this.mapper.realClass(hierarchicalStreamReader.getNodeName())));
+            hierarchicalStreamReader.moveUp();
+        }
+        enhancer.setInterfaces((Class[]) arrayList.toArray(new Class[arrayList.size()]));
+        hierarchicalStreamReader.moveUp();
+        hierarchicalStreamReader.moveDown();
+        boolean booleanValue = Boolean.valueOf(hierarchicalStreamReader.getValue()).booleanValue();
+        enhancer.setUseFactory(booleanValue);
+        hierarchicalStreamReader.moveUp();
+        ArrayList arrayList2 = new ArrayList();
+        ArrayList arrayList3 = new ArrayList();
+        hierarchicalStreamReader.moveDown();
+        if ("callbacks".equals(hierarchicalStreamReader.getNodeName())) {
+            hierarchicalStreamReader.moveDown();
+            Class cls2 = class$java$util$HashMap;
+            if (cls2 == null) {
+                cls2 = class$("java.util.HashMap");
+                class$java$util$HashMap = cls2;
+            }
+            map = (Map) unmarshallingContext.convertAnother(null, cls2);
+            hierarchicalStreamReader.moveUp();
+            while (hierarchicalStreamReader.hasMoreChildren()) {
+                hierarchicalStreamReader.moveDown();
+                readCallback(hierarchicalStreamReader, unmarshallingContext, arrayList2, arrayList3);
+                hierarchicalStreamReader.moveUp();
+            }
+        } else {
+            readCallback(hierarchicalStreamReader, unmarshallingContext, arrayList2, arrayList3);
+            map = null;
+        }
+        enhancer.setCallbacks((Callback[]) arrayList2.toArray(new Callback[arrayList2.size()]));
+        if (map != null) {
+            enhancer.setCallbackFilter(new ReverseEngineeredCallbackFilter(map));
+        }
+        hierarchicalStreamReader.moveUp();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            if (hierarchicalStreamReader.getNodeName().equals("serialVersionUID")) {
+                enhancer.setSerialVersionUID(Long.valueOf(hierarchicalStreamReader.getValue()));
+            } else if (hierarchicalStreamReader.getNodeName().equals("instance")) {
+                obj = create(enhancer, arrayList3, booleanValue);
+                super.doUnmarshalConditionally(obj, hierarchicalStreamReader, unmarshallingContext);
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        if (obj == null) {
+            obj = create(enhancer, arrayList3, booleanValue);
+        }
+        return this.serializationMembers.callReadResolve(obj);
+    }
+
+    public CGLIBEnhancedConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoader classLoader) {
+        super(mapper, new CGLIBFilteringReflectionProvider(reflectionProvider), classLoader);
+        this.fieldCache = new HashMap();
+    }
+
+    /* 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 CGLIBEnhancedConverter(com.thoughtworks.xstream.mapper.Mapper r2, com.thoughtworks.xstream.converters.reflection.ReflectionProvider r3) {
+        /*
+            r1 = this;
+            com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter$CGLIBFilteringReflectionProvider r0 = new com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter$CGLIBFilteringReflectionProvider
+            r0.<init>(r3)
+            java.lang.Class r3 = com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter
+            if (r3 != 0) goto L11
+            java.lang.String r3 = "com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter"
+            java.lang.Class r3 = class$(r3)
+            com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter = r3
+        L11:
+            java.lang.ClassLoader r3 = r3.getClassLoader()
+            r1.<init>(r2, r0, r3)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.<init>(com.thoughtworks.xstream.mapper.Mapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider):void");
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/ExternalizableConverter.java

@@ -0,0 +1,211 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+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.JVM;
+import com.thoughtworks.xstream.core.ReferencingMarshallingContext;
+import com.thoughtworks.xstream.core.util.CustomObjectInputStream;
+import com.thoughtworks.xstream.core.util.CustomObjectOutputStream;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.core.util.SerializationMembers;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.io.StreamException;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.NotActiveException;
+import java.io.ObjectInputValidation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class ExternalizableConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$ExternalizableConverter;
+    static /* synthetic */ Class class$java$io$Externalizable;
+    private final ClassLoaderReference classLoaderReference;
+    private Mapper mapper;
+    private transient SerializationMembers serializationMembers;
+
+    public ExternalizableConverter(Mapper mapper, ClassLoaderReference classLoaderReference) {
+        this.mapper = mapper;
+        this.classLoaderReference = classLoaderReference;
+        this.serializationMembers = new SerializationMembers();
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private Object readResolve() {
+        this.serializationMembers = new SerializationMembers();
+        return this;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null && JVM.canCreateDerivedObjectOutputStream()) {
+            Class cls2 = class$java$io$Externalizable;
+            if (cls2 == null) {
+                cls2 = class$("java.io.Externalizable");
+                class$java$io$Externalizable = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, final MarshallingContext marshallingContext) {
+        Object callWriteReplace = this.serializationMembers.callWriteReplace(obj);
+        if (callWriteReplace != obj && (marshallingContext instanceof ReferencingMarshallingContext)) {
+            ((ReferencingMarshallingContext) marshallingContext).replace(obj, callWriteReplace);
+        }
+        if (callWriteReplace.getClass() != obj.getClass()) {
+            String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("resolves-to");
+            if (aliasForSystemAttribute != null) {
+                hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(callWriteReplace.getClass()));
+            }
+            marshallingContext.convertAnother(callWriteReplace);
+            return;
+        }
+        try {
+            CustomObjectOutputStream customObjectOutputStream = CustomObjectOutputStream.getInstance(marshallingContext, new CustomObjectOutputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.ExternalizableConverter.1
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
+                public void close() {
+                    throw new UnsupportedOperationException("Objects are not allowed to call ObjectOutput.close() from writeExternal()");
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
+                public void defaultWriteObject() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
+                public void flush() {
+                    hierarchicalStreamWriter.flush();
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
+                public void writeFieldsToStream(Map map) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
+                public void writeToStream(Object obj2) {
+                    if (obj2 == null) {
+                        hierarchicalStreamWriter.startNode("null");
+                        hierarchicalStreamWriter.endNode();
+                    } else {
+                        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, ExternalizableConverter.this.mapper.serializedClass(obj2.getClass()), obj2.getClass());
+                        marshallingContext.convertAnother(obj2);
+                        hierarchicalStreamWriter.endNode();
+                    }
+                }
+            });
+            ((Externalizable) callWriteReplace).writeExternal(customObjectOutputStream);
+            customObjectOutputStream.popCallback();
+        } catch (IOException e) {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append("Cannot serialize ");
+            stringBuffer.append(callWriteReplace.getClass().getName());
+            stringBuffer.append(" using Externalization");
+            throw new StreamException(stringBuffer.toString(), e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(final HierarchicalStreamReader hierarchicalStreamReader, final UnmarshallingContext unmarshallingContext) {
+        Class requiredType = unmarshallingContext.getRequiredType();
+        try {
+            Constructor declaredConstructor = requiredType.getDeclaredConstructor(null);
+            if (!declaredConstructor.isAccessible()) {
+                declaredConstructor.setAccessible(true);
+            }
+            final Externalizable externalizable = (Externalizable) declaredConstructor.newInstance(null);
+            CustomObjectInputStream customObjectInputStream = CustomObjectInputStream.getInstance(unmarshallingContext, new CustomObjectInputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.ExternalizableConverter.2
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
+                public void close() {
+                    throw new UnsupportedOperationException("Objects are not allowed to call ObjectInput.close() from readExternal()");
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
+                public void defaultReadObject() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
+                public Map readFieldsFromStream() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
+                public Object readFromStream() {
+                    hierarchicalStreamReader.moveDown();
+                    Object convertAnother = unmarshallingContext.convertAnother(externalizable, HierarchicalStreams.readClassType(hierarchicalStreamReader, ExternalizableConverter.this.mapper));
+                    hierarchicalStreamReader.moveUp();
+                    return convertAnother;
+                }
+
+                @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
+                public void registerValidation(ObjectInputValidation objectInputValidation, int i) throws NotActiveException {
+                    throw new NotActiveException("stream inactive");
+                }
+            }, this.classLoaderReference);
+            externalizable.readExternal(customObjectInputStream);
+            customObjectInputStream.popCallback();
+            return this.serializationMembers.callReadResolve(externalizable);
+        } catch (IOException e) {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append("Cannot externalize ");
+            stringBuffer.append(requiredType.getClass());
+            throw new StreamException(stringBuffer.toString(), e);
+        } catch (ClassNotFoundException e2) {
+            throw new ConversionException("Cannot construct type", e2);
+        } catch (IllegalAccessException e3) {
+            throw new ObjectAccessException("Cannot construct type", e3);
+        } catch (InstantiationException e4) {
+            throw new ConversionException("Cannot construct type", e4);
+        } catch (NoSuchMethodException e5) {
+            throw new ConversionException("Missing default constructor of type", e5);
+        } catch (InvocationTargetException e6) {
+            throw new ConversionException("Cannot construct type", e6);
+        }
+    }
+
+    public ExternalizableConverter(Mapper mapper, ClassLoader classLoader) {
+        this(mapper, new ClassLoaderReference(classLoader));
+    }
+
+    /* 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 ExternalizableConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
+        /*
+            r1 = this;
+            java.lang.Class r0 = com.thoughtworks.xstream.converters.reflection.ExternalizableConverter.class$com$thoughtworks$xstream$converters$reflection$ExternalizableConverter
+            if (r0 != 0) goto Lc
+            java.lang.String r0 = "com.thoughtworks.xstream.converters.reflection.ExternalizableConverter"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.converters.reflection.ExternalizableConverter.class$com$thoughtworks$xstream$converters$reflection$ExternalizableConverter = r0
+        Lc:
+            java.lang.ClassLoader r0 = r0.getClassLoader()
+            r1.<init>(r2, r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.ExternalizableConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/FieldDictionary.java

@@ -0,0 +1,186 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import com.thoughtworks.xstream.core.Caching;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.OrderRetainingMap;
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class FieldDictionary implements Caching {
+    private static final DictionaryEntry OBJECT_DICTIONARY_ENTRY;
+    static /* synthetic */ Class class$java$lang$Object;
+    private transient Map dictionaryEntries;
+    private transient FieldUtil fieldUtil;
+    private final FieldKeySorter sorter;
+
+    private static final class DictionaryEntry {
+        private final Map keyedByFieldKey;
+        private final Map keyedByFieldName;
+
+        public DictionaryEntry(Map map, Map map2) {
+            this.keyedByFieldName = map;
+            this.keyedByFieldKey = map2;
+        }
+
+        public Map getKeyedByFieldKey() {
+            return this.keyedByFieldKey;
+        }
+
+        public Map getKeyedByFieldName() {
+            return this.keyedByFieldName;
+        }
+    }
+
+    interface FieldUtil {
+        boolean isSynthetic(Field field);
+    }
+
+    static {
+        Map map = Collections.EMPTY_MAP;
+        OBJECT_DICTIONARY_ENTRY = new DictionaryEntry(map, map);
+    }
+
+    public FieldDictionary() {
+        this(new ImmutableFieldKeySorter());
+    }
+
+    private DictionaryEntry buildDictionaryEntryForClass(Class cls, DictionaryEntry dictionaryEntry) {
+        HashMap hashMap = new HashMap(dictionaryEntry.getKeyedByFieldName());
+        OrderRetainingMap orderRetainingMap = new OrderRetainingMap(dictionaryEntry.getKeyedByFieldKey());
+        Field[] declaredFields = cls.getDeclaredFields();
+        if (JVM.reverseFieldDefinition()) {
+            int length = declaredFields.length >> 1;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                int length2 = (declaredFields.length - i) - 1;
+                Field field = declaredFields[i];
+                declaredFields[i] = declaredFields[length2];
+                declaredFields[length2] = field;
+                length = i;
+            }
+        }
+        for (int i2 = 0; i2 < declaredFields.length; i2++) {
+            Field field2 = declaredFields[i2];
+            if (!this.fieldUtil.isSynthetic(field2) || !field2.getName().startsWith("$jacoco")) {
+                if (!field2.isAccessible()) {
+                    field2.setAccessible(true);
+                }
+                FieldKey fieldKey = new FieldKey(field2.getName(), field2.getDeclaringClass(), i2);
+                Field field3 = (Field) hashMap.get(field2.getName());
+                if (field3 == null || (field3.getModifiers() & 8) != 0 || (field3 != null && (field2.getModifiers() & 8) == 0)) {
+                    hashMap.put(field2.getName(), field2);
+                }
+                orderRetainingMap.put(fieldKey, field2);
+            }
+        }
+        return new DictionaryEntry(hashMap, this.sorter.sort(cls, orderRetainingMap));
+    }
+
+    private Map buildMap(Class cls, boolean z) {
+        LinkedList linkedList = new LinkedList();
+        DictionaryEntry dictionaryEntry = null;
+        while (dictionaryEntry == null) {
+            Class cls2 = class$java$lang$Object;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Object");
+                class$java$lang$Object = cls2;
+            }
+            dictionaryEntry = (cls2.equals(cls) || cls == null) ? OBJECT_DICTIONARY_ENTRY : getDictionaryEntry(cls);
+            if (dictionaryEntry == null) {
+                linkedList.addFirst(cls);
+                cls = cls.getSuperclass();
+            }
+        }
+        Iterator it = linkedList.iterator();
+        while (it.hasNext()) {
+            Class cls3 = (Class) it.next();
+            dictionaryEntry = buildDictionaryEntryForClass(cls3, dictionaryEntry);
+            synchronized (this) {
+                DictionaryEntry dictionaryEntry2 = getDictionaryEntry(cls3);
+                if (dictionaryEntry2 == null) {
+                    this.dictionaryEntries.put(cls3, dictionaryEntry);
+                } else {
+                    dictionaryEntry = dictionaryEntry2;
+                }
+            }
+        }
+        return z ? dictionaryEntry.getKeyedByFieldKey() : dictionaryEntry.getKeyedByFieldName();
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private synchronized DictionaryEntry getDictionaryEntry(Class cls) {
+        return (DictionaryEntry) this.dictionaryEntries.get(cls);
+    }
+
+    private void init() {
+        this.dictionaryEntries = new HashMap();
+        if (JVM.is15()) {
+            try {
+                this.fieldUtil = (FieldUtil) JVM.loadClassForName("com.thoughtworks.xstream.converters.reflection.FieldUtil15", true).newInstance();
+            } catch (Exception unused) {
+            }
+        }
+        if (this.fieldUtil == null) {
+            this.fieldUtil = new FieldUtil14();
+        }
+    }
+
+    public Field field(Class cls, String str, Class cls2) {
+        Field fieldOrNull = fieldOrNull(cls, str, cls2);
+        if (fieldOrNull != null) {
+            return fieldOrNull;
+        }
+        throw new MissingFieldException(cls.getName(), str);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v2, types: [com.thoughtworks.xstream.converters.reflection.FieldKey] */
+    public Field fieldOrNull(Class cls, String str, Class cls2) {
+        Map buildMap = buildMap(cls, cls2 != null);
+        if (cls2 != null) {
+            str = new FieldKey(str, cls2, -1);
+        }
+        return (Field) buildMap.get(str);
+    }
+
+    public Iterator fieldsFor(Class cls) {
+        return buildMap(cls, true).values().iterator();
+    }
+
+    @Override // com.thoughtworks.xstream.core.Caching
+    public synchronized void flushCache() {
+        this.dictionaryEntries.clear();
+        if (this.sorter instanceof Caching) {
+            ((Caching) this.sorter).flushCache();
+        }
+    }
+
+    protected Object readResolve() {
+        init();
+        return this;
+    }
+
+    public Iterator serializableFieldsFor(Class cls) {
+        return fieldsFor(cls);
+    }
+
+    public FieldDictionary(FieldKeySorter fieldKeySorter) {
+        this.sorter = fieldKeySorter;
+        init();
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/FieldKey.java

@@ -0,0 +1,69 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+/* loaded from: classes.dex */
+public class FieldKey {
+    private final Class declaringClass;
+    private final int depth;
+    private final String fieldName;
+    private final int order;
+
+    public FieldKey(String str, Class cls, int i) {
+        if (str == null || cls == null) {
+            throw new IllegalArgumentException("fieldName or declaringClass is null");
+        }
+        this.fieldName = str;
+        this.declaringClass = cls;
+        this.order = i;
+        int i2 = 0;
+        while (cls.getSuperclass() != null) {
+            i2++;
+            cls = cls.getSuperclass();
+        }
+        this.depth = i2;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof FieldKey)) {
+            return false;
+        }
+        FieldKey fieldKey = (FieldKey) obj;
+        return this.declaringClass.equals(fieldKey.declaringClass) && this.fieldName.equals(fieldKey.fieldName);
+    }
+
+    public Class getDeclaringClass() {
+        return this.declaringClass;
+    }
+
+    public int getDepth() {
+        return this.depth;
+    }
+
+    public String getFieldName() {
+        return this.fieldName;
+    }
+
+    public int getOrder() {
+        return this.order;
+    }
+
+    public int hashCode() {
+        return (this.fieldName.hashCode() * 29) + this.declaringClass.hashCode();
+    }
+
+    public String toString() {
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("FieldKey{order=");
+        stringBuffer.append(this.order);
+        stringBuffer.append(", writer=");
+        stringBuffer.append(this.depth);
+        stringBuffer.append(", declaringClass=");
+        stringBuffer.append(this.declaringClass);
+        stringBuffer.append(", fieldName='");
+        stringBuffer.append(this.fieldName);
+        stringBuffer.append("'}");
+        return stringBuffer.toString();
+    }
+}

sources/com/thoughtworks/xstream/converters/reflection/FieldKeySorter.java

@@ -0,0 +1,8 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public interface FieldKeySorter {
+    Map sort(Class cls, Map map);
+}

sources/com/thoughtworks/xstream/converters/reflection/FieldUtil14.java

@@ -0,0 +1,15 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import com.thoughtworks.xstream.converters.reflection.FieldDictionary;
+import java.lang.reflect.Field;
+
+/* loaded from: classes.dex */
+class FieldUtil14 implements FieldDictionary.FieldUtil {
+    FieldUtil14() {
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.FieldDictionary.FieldUtil
+    public boolean isSynthetic(Field field) {
+        return false;
+    }
+}