Initial commit

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