package com.thoughtworks.xstream;

import com.liulishuo.filedownloader.model.FileDownloadModel;
import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.ConverterLookup;
import com.thoughtworks.xstream.converters.ConverterRegistry;
import com.thoughtworks.xstream.converters.DataHolder;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.SingleValueConverter;
import com.thoughtworks.xstream.converters.SingleValueConverterWrapper;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.converters.basic.BigDecimalConverter;
import com.thoughtworks.xstream.converters.basic.BigIntegerConverter;
import com.thoughtworks.xstream.converters.basic.BooleanConverter;
import com.thoughtworks.xstream.converters.basic.ByteConverter;
import com.thoughtworks.xstream.converters.basic.CharConverter;
import com.thoughtworks.xstream.converters.basic.DateConverter;
import com.thoughtworks.xstream.converters.basic.DoubleConverter;
import com.thoughtworks.xstream.converters.basic.FloatConverter;
import com.thoughtworks.xstream.converters.basic.IntConverter;
import com.thoughtworks.xstream.converters.basic.LongConverter;
import com.thoughtworks.xstream.converters.basic.NullConverter;
import com.thoughtworks.xstream.converters.basic.ShortConverter;
import com.thoughtworks.xstream.converters.basic.StringBufferConverter;
import com.thoughtworks.xstream.converters.basic.StringConverter;
import com.thoughtworks.xstream.converters.basic.URIConverter;
import com.thoughtworks.xstream.converters.basic.URLConverter;
import com.thoughtworks.xstream.converters.collections.ArrayConverter;
import com.thoughtworks.xstream.converters.collections.BitSetConverter;
import com.thoughtworks.xstream.converters.collections.CharArrayConverter;
import com.thoughtworks.xstream.converters.collections.CollectionConverter;
import com.thoughtworks.xstream.converters.collections.MapConverter;
import com.thoughtworks.xstream.converters.collections.PropertiesConverter;
import com.thoughtworks.xstream.converters.collections.SingletonCollectionConverter;
import com.thoughtworks.xstream.converters.collections.SingletonMapConverter;
import com.thoughtworks.xstream.converters.collections.TreeMapConverter;
import com.thoughtworks.xstream.converters.collections.TreeSetConverter;
import com.thoughtworks.xstream.converters.extended.ColorConverter;
import com.thoughtworks.xstream.converters.extended.DynamicProxyConverter;
import com.thoughtworks.xstream.converters.extended.EncodedByteArrayConverter;
import com.thoughtworks.xstream.converters.extended.FileConverter;
import com.thoughtworks.xstream.converters.extended.FontConverter;
import com.thoughtworks.xstream.converters.extended.GregorianCalendarConverter;
import com.thoughtworks.xstream.converters.extended.JavaClassConverter;
import com.thoughtworks.xstream.converters.extended.JavaFieldConverter;
import com.thoughtworks.xstream.converters.extended.JavaMethodConverter;
import com.thoughtworks.xstream.converters.extended.LocaleConverter;
import com.thoughtworks.xstream.converters.extended.LookAndFeelConverter;
import com.thoughtworks.xstream.converters.extended.SqlDateConverter;
import com.thoughtworks.xstream.converters.extended.SqlTimeConverter;
import com.thoughtworks.xstream.converters.extended.SqlTimestampConverter;
import com.thoughtworks.xstream.converters.extended.TextAttributeConverter;
import com.thoughtworks.xstream.converters.reflection.ExternalizableConverter;
import com.thoughtworks.xstream.converters.reflection.ReflectionConverter;
import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
import com.thoughtworks.xstream.converters.reflection.SerializableConverter;
import com.thoughtworks.xstream.core.ClassLoaderReference;
import com.thoughtworks.xstream.core.DefaultConverterLookup;
import com.thoughtworks.xstream.core.JVM;
import com.thoughtworks.xstream.core.MapBackedDataHolder;
import com.thoughtworks.xstream.core.ReferenceByIdMarshallingStrategy;
import com.thoughtworks.xstream.core.ReferenceByXPathMarshallingStrategy;
import com.thoughtworks.xstream.core.TreeMarshallingStrategy;
import com.thoughtworks.xstream.core.util.CompositeClassLoader;
import com.thoughtworks.xstream.core.util.CustomObjectInputStream;
import com.thoughtworks.xstream.core.util.CustomObjectOutputStream;
import com.thoughtworks.xstream.core.util.SelfStreamingInstanceChecker;
import com.thoughtworks.xstream.io.HierarchicalStreamDriver;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.StatefulWriter;
import com.thoughtworks.xstream.io.xml.XppDriver;
import com.thoughtworks.xstream.mapper.AnnotationConfiguration;
import com.thoughtworks.xstream.mapper.ArrayMapper;
import com.thoughtworks.xstream.mapper.AttributeAliasingMapper;
import com.thoughtworks.xstream.mapper.AttributeMapper;
import com.thoughtworks.xstream.mapper.CachingMapper;
import com.thoughtworks.xstream.mapper.ClassAliasingMapper;
import com.thoughtworks.xstream.mapper.DefaultImplementationsMapper;
import com.thoughtworks.xstream.mapper.DefaultMapper;
import com.thoughtworks.xstream.mapper.DynamicProxyMapper;
import com.thoughtworks.xstream.mapper.ElementIgnoringMapper;
import com.thoughtworks.xstream.mapper.FieldAliasingMapper;
import com.thoughtworks.xstream.mapper.ImmutableTypesMapper;
import com.thoughtworks.xstream.mapper.ImplicitCollectionMapper;
import com.thoughtworks.xstream.mapper.LocalConversionMapper;
import com.thoughtworks.xstream.mapper.Mapper;
import com.thoughtworks.xstream.mapper.MapperWrapper;
import com.thoughtworks.xstream.mapper.OuterClassMapper;
import com.thoughtworks.xstream.mapper.PackageAliasingMapper;
import com.thoughtworks.xstream.mapper.SecurityMapper;
import com.thoughtworks.xstream.mapper.SystemAttributeAliasingMapper;
import com.thoughtworks.xstream.mapper.XStream11XmlFriendlyMapper;
import com.thoughtworks.xstream.security.AnyTypePermission;
import com.thoughtworks.xstream.security.ArrayTypePermission;
import com.thoughtworks.xstream.security.ExplicitTypePermission;
import com.thoughtworks.xstream.security.InterfaceTypePermission;
import com.thoughtworks.xstream.security.NoPermission;
import com.thoughtworks.xstream.security.NoTypePermission;
import com.thoughtworks.xstream.security.NullPermission;
import com.thoughtworks.xstream.security.PrimitiveTypePermission;
import com.thoughtworks.xstream.security.RegExpTypePermission;
import com.thoughtworks.xstream.security.TypeHierarchyPermission;
import com.thoughtworks.xstream.security.TypePermission;
import com.thoughtworks.xstream.security.WildcardTypePermission;
import com.ubt.jimu.diy.view.fragment.BuildStepFragment;
import com.unity3d.ads.metadata.InAppPurchaseMetaData;
import com.unity3d.ads.metadata.MediationMetaData;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.NotActiveException;
import java.io.ObjectInputStream;
import java.io.ObjectInputValidation;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.regex.Pattern;

/* loaded from: classes.dex */
public class XStream {
    private static final String ANNOTATION_MAPPER_TYPE = "com.thoughtworks.xstream.mapper.AnnotationMapper";
    public static final int ID_REFERENCES = 1002;
    private static final Pattern IGNORE_ALL = Pattern.compile(".*");
    public static final int NO_REFERENCES = 1001;
    public static final int PRIORITY_LOW = -10;
    public static final int PRIORITY_NORMAL = 0;
    public static final int PRIORITY_VERY_HIGH = 10000;
    public static final int PRIORITY_VERY_LOW = -20;
    public static final int SINGLE_NODE_XPATH_ABSOLUTE_REFERENCES = 1006;
    public static final int SINGLE_NODE_XPATH_RELATIVE_REFERENCES = 1005;
    public static final int XPATH_ABSOLUTE_REFERENCES = 1004;
    public static final int XPATH_RELATIVE_REFERENCES = 1003;
    static /* synthetic */ Class array$Ljava$lang$String;
    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$ConverterLookup;
    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$ConverterRegistry;
    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider;
    static /* synthetic */ Class class$com$thoughtworks$xstream$core$ClassLoaderReference;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$AnnotationConfiguration;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$AttributeAliasingMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$AttributeMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$ClassAliasingMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$DefaultImplementationsMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$FieldAliasingMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$ImmutableTypesMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$ImplicitCollectionMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$LocalConversionMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$PackageAliasingMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$SecurityMapper;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$SystemAttributeAliasingMapper;
    static /* synthetic */ Class class$java$io$File;
    static /* synthetic */ Class class$java$lang$Boolean;
    static /* synthetic */ Class class$java$lang$Byte;
    static /* synthetic */ Class class$java$lang$Character;
    static /* synthetic */ Class class$java$lang$Class;
    static /* synthetic */ Class class$java$lang$Double;
    static /* synthetic */ Class class$java$lang$Float;
    static /* synthetic */ Class class$java$lang$Integer;
    static /* synthetic */ Class class$java$lang$Long;
    static /* synthetic */ Class class$java$lang$Number;
    static /* synthetic */ Class class$java$lang$Object;
    static /* synthetic */ Class class$java$lang$Short;
    static /* synthetic */ Class class$java$lang$StackTraceElement;
    static /* synthetic */ Class class$java$lang$String;
    static /* synthetic */ Class class$java$lang$StringBuffer;
    static /* synthetic */ Class class$java$lang$Throwable;
    static /* synthetic */ Class class$java$lang$Void;
    static /* synthetic */ Class class$java$lang$reflect$Constructor;
    static /* synthetic */ Class class$java$lang$reflect$Field;
    static /* synthetic */ Class class$java$lang$reflect$Member;
    static /* synthetic */ Class class$java$lang$reflect$Method;
    static /* synthetic */ Class class$java$math$BigDecimal;
    static /* synthetic */ Class class$java$math$BigInteger;
    static /* synthetic */ Class class$java$net$URI;
    static /* synthetic */ Class class$java$net$URL;
    static /* synthetic */ Class class$java$nio$charset$Charset;
    static /* synthetic */ Class class$java$text$DecimalFormatSymbols;
    static /* synthetic */ Class class$java$util$ArrayList;
    static /* synthetic */ Class class$java$util$BitSet;
    static /* synthetic */ Class class$java$util$Calendar;
    static /* synthetic */ Class class$java$util$Collection;
    static /* synthetic */ Class class$java$util$Currency;
    static /* synthetic */ Class class$java$util$Date;
    static /* synthetic */ Class class$java$util$GregorianCalendar;
    static /* synthetic */ Class class$java$util$HashMap;
    static /* synthetic */ Class class$java$util$HashSet;
    static /* synthetic */ Class class$java$util$Hashtable;
    static /* synthetic */ Class class$java$util$LinkedList;
    static /* synthetic */ Class class$java$util$List;
    static /* synthetic */ Class class$java$util$Locale;
    static /* synthetic */ Class class$java$util$Map;
    static /* synthetic */ Class class$java$util$Map$Entry;
    static /* synthetic */ Class class$java$util$Properties;
    static /* synthetic */ Class class$java$util$Set;
    static /* synthetic */ Class class$java$util$SortedSet;
    static /* synthetic */ Class class$java$util$TimeZone;
    static /* synthetic */ Class class$java$util$TreeMap;
    static /* synthetic */ Class class$java$util$TreeSet;
    static /* synthetic */ Class class$java$util$Vector;
    static /* synthetic */ Class class$java$util$regex$Pattern;
    private AnnotationConfiguration annotationConfiguration;
    private AttributeAliasingMapper attributeAliasingMapper;
    private AttributeMapper attributeMapper;
    private ClassAliasingMapper classAliasingMapper;
    private ClassLoaderReference classLoaderReference;
    private ConverterLookup converterLookup;
    private ConverterRegistry converterRegistry;
    private DefaultImplementationsMapper defaultImplementationsMapper;
    private ElementIgnoringMapper elementIgnoringMapper;
    private FieldAliasingMapper fieldAliasingMapper;
    private HierarchicalStreamDriver hierarchicalStreamDriver;
    private ImmutableTypesMapper immutableTypesMapper;
    private ImplicitCollectionMapper implicitCollectionMapper;
    private LocalConversionMapper localConversionMapper;
    private Mapper mapper;
    private MarshallingStrategy marshallingStrategy;
    private PackageAliasingMapper packageAliasingMapper;
    private ReflectionProvider reflectionProvider;
    private transient boolean securityInitialized;
    private SecurityMapper securityMapper;
    private transient boolean securityWarningGiven;
    private SystemAttributeAliasingMapper systemAttributeAliasingMapper;

    public static class InitializationException extends XStreamException {
        public InitializationException(String str, Throwable th) {
            super(str, th);
        }

        public InitializationException(String str) {
            super(str);
        }
    }

    private class InternalBlackList implements Converter {
        private InternalBlackList() {
        }

        @Override // com.thoughtworks.xstream.converters.ConverterMatcher
        public boolean canConvert(Class cls) {
            if (cls != Void.TYPE) {
                Class cls2 = XStream.class$java$lang$Void;
                if (cls2 == null) {
                    cls2 = XStream.class$("java.lang.Void");
                    XStream.class$java$lang$Void = cls2;
                }
                if (cls != cls2 && (XStream.this.securityInitialized || cls == null || (!cls.getName().equals("java.beans.EventHandler") && !cls.getName().endsWith("$LazyIterator") && !cls.getName().startsWith("javax.crypto.")))) {
                    return false;
                }
            }
            return true;
        }

        @Override // com.thoughtworks.xstream.converters.Converter
        public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
            throw new ConversionException("Security alert. Marshalling rejected.");
        }

        @Override // com.thoughtworks.xstream.converters.Converter
        public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
            throw new ConversionException("Security alert. Unmarshalling rejected.");
        }
    }

    public XStream() {
        this((ReflectionProvider) null, (Mapper) null, new XppDriver());
    }

    private void addImmutableTypeDynamically(String str, boolean z) {
        Class loadClassForName = JVM.loadClassForName(str);
        if (loadClassForName != null) {
            addImmutableType(loadClassForName, z);
        }
    }

    private void aliasDynamically(String str, String str2) {
        Class loadClassForName = JVM.loadClassForName(str2);
        if (loadClassForName != null) {
            alias(str, loadClassForName);
        }
    }

    private Mapper buildMapper() {
        Mapper defaultMapper = new DefaultMapper(this.classLoaderReference);
        if (useXStream11XmlFriendlyMapper()) {
            defaultMapper = new XStream11XmlFriendlyMapper(defaultMapper);
        }
        Mapper attributeMapper = new AttributeMapper(new DefaultImplementationsMapper(new ArrayMapper(new OuterClassMapper(new ImplicitCollectionMapper(new SystemAttributeAliasingMapper(new AttributeAliasingMapper(new FieldAliasingMapper(new ElementIgnoringMapper(new ClassAliasingMapper(new PackageAliasingMapper(new DynamicProxyMapper(defaultMapper))))))), this.reflectionProvider)))), this.converterLookup, this.reflectionProvider);
        if (JVM.isVersion(5)) {
            Class[] clsArr = new Class[1];
            Class cls = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls == null) {
                cls = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls;
            }
            clsArr[0] = cls;
            attributeMapper = buildMapperDynamically("com.thoughtworks.xstream.mapper.EnumMapper", clsArr, new Object[]{attributeMapper});
        }
        Mapper immutableTypesMapper = new ImmutableTypesMapper(new LocalConversionMapper(attributeMapper));
        if (JVM.isVersion(8)) {
            Class[] clsArr2 = new Class[1];
            Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls2;
            }
            clsArr2[0] = cls2;
            immutableTypesMapper = buildMapperDynamically("com.thoughtworks.xstream.mapper.LambdaMapper", clsArr2, new Object[]{immutableTypesMapper});
        }
        Mapper securityMapper = new SecurityMapper(immutableTypesMapper);
        if (JVM.isVersion(5)) {
            Class[] clsArr3 = new Class[5];
            Class cls3 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls3 == null) {
                cls3 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls3;
            }
            clsArr3[0] = cls3;
            Class cls4 = class$com$thoughtworks$xstream$converters$ConverterRegistry;
            if (cls4 == null) {
                cls4 = class$("com.thoughtworks.xstream.converters.ConverterRegistry");
                class$com$thoughtworks$xstream$converters$ConverterRegistry = cls4;
            }
            clsArr3[1] = cls4;
            Class cls5 = class$com$thoughtworks$xstream$converters$ConverterLookup;
            if (cls5 == null) {
                cls5 = class$("com.thoughtworks.xstream.converters.ConverterLookup");
                class$com$thoughtworks$xstream$converters$ConverterLookup = cls5;
            }
            clsArr3[2] = cls5;
            Class cls6 = class$com$thoughtworks$xstream$core$ClassLoaderReference;
            if (cls6 == null) {
                cls6 = class$("com.thoughtworks.xstream.core.ClassLoaderReference");
                class$com$thoughtworks$xstream$core$ClassLoaderReference = cls6;
            }
            clsArr3[3] = cls6;
            Class cls7 = class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider;
            if (cls7 == null) {
                cls7 = class$("com.thoughtworks.xstream.converters.reflection.ReflectionProvider");
                class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider = cls7;
            }
            clsArr3[4] = cls7;
            securityMapper = buildMapperDynamically(ANNOTATION_MAPPER_TYPE, clsArr3, new Object[]{securityMapper, this.converterRegistry, this.converterLookup, this.classLoaderReference, this.reflectionProvider});
        }
        return new CachingMapper(wrapMapper((MapperWrapper) securityMapper));
    }

    private Mapper buildMapperDynamically(String str, Class[] clsArr, Object[] objArr) {
        try {
            return (Mapper) Class.forName(str, false, this.classLoaderReference.getReference()).getConstructor(clsArr).newInstance(objArr);
        } catch (Exception e) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("Could not instantiate mapper : ");
            stringBuffer.append(str);
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString(), e);
        } catch (LinkageError e2) {
            StringBuffer stringBuffer2 = new StringBuffer();
            stringBuffer2.append("Could not instantiate mapper : ");
            stringBuffer2.append(str);
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer2.toString(), e2);
        }
    }

    static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError().initCause(e);
        }
    }

    private Object readResolve() {
        this.securityWarningGiven = true;
        return this;
    }

    private void registerConverterDynamically(String str, int i, Class[] clsArr, Object[] objArr) {
        try {
            Object newInstance = Class.forName(str, false, this.classLoaderReference.getReference()).getConstructor(clsArr).newInstance(objArr);
            if (newInstance instanceof Converter) {
                registerConverter((Converter) newInstance, i);
            } else if (newInstance instanceof SingleValueConverter) {
                registerConverter((SingleValueConverter) newInstance, i);
            }
        } catch (Exception e) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("Could not instantiate converter : ");
            stringBuffer.append(str);
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString(), e);
        } catch (LinkageError e2) {
            StringBuffer stringBuffer2 = new StringBuffer();
            stringBuffer2.append("Could not instantiate converter : ");
            stringBuffer2.append(str);
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer2.toString(), e2);
        }
    }

    public static void setupDefaultSecurity(XStream xStream) {
        if (xStream.securityInitialized) {
            throw new IllegalArgumentException("Security framework of XStream instance already initialized");
        }
        xStream.addPermission(NoTypePermission.NONE);
        xStream.addPermission(NullPermission.NULL);
        xStream.addPermission(PrimitiveTypePermission.PRIMITIVES);
        xStream.addPermission(ArrayTypePermission.ARRAYS);
        xStream.addPermission(InterfaceTypePermission.INTERFACES);
        Class cls = class$java$util$Calendar;
        if (cls == null) {
            cls = class$("java.util.Calendar");
            class$java$util$Calendar = cls;
        }
        xStream.allowTypeHierarchy(cls);
        Class cls2 = class$java$util$Collection;
        if (cls2 == null) {
            cls2 = class$("java.util.Collection");
            class$java$util$Collection = cls2;
        }
        xStream.allowTypeHierarchy(cls2);
        Class cls3 = class$java$util$Map;
        if (cls3 == null) {
            cls3 = class$("java.util.Map");
            class$java$util$Map = cls3;
        }
        xStream.allowTypeHierarchy(cls3);
        Class cls4 = class$java$util$Map$Entry;
        if (cls4 == null) {
            cls4 = class$("java.util.Map$Entry");
            class$java$util$Map$Entry = cls4;
        }
        xStream.allowTypeHierarchy(cls4);
        Class cls5 = class$java$lang$reflect$Member;
        if (cls5 == null) {
            cls5 = class$("java.lang.reflect.Member");
            class$java$lang$reflect$Member = cls5;
        }
        xStream.allowTypeHierarchy(cls5);
        Class cls6 = class$java$lang$Number;
        if (cls6 == null) {
            cls6 = class$("java.lang.Number");
            class$java$lang$Number = cls6;
        }
        xStream.allowTypeHierarchy(cls6);
        Class cls7 = class$java$lang$Throwable;
        if (cls7 == null) {
            cls7 = class$("java.lang.Throwable");
            class$java$lang$Throwable = cls7;
        }
        xStream.allowTypeHierarchy(cls7);
        Class cls8 = class$java$util$TimeZone;
        if (cls8 == null) {
            cls8 = class$("java.util.TimeZone");
            class$java$util$TimeZone = cls8;
        }
        xStream.allowTypeHierarchy(cls8);
        Class loadClassForName = JVM.loadClassForName("java.lang.Enum");
        if (loadClassForName != null) {
            xStream.allowTypeHierarchy(loadClassForName);
        }
        Class loadClassForName2 = JVM.loadClassForName("java.nio.file.Path");
        if (loadClassForName2 != null) {
            xStream.allowTypeHierarchy(loadClassForName2);
        }
        HashSet hashSet = new HashSet();
        Class cls9 = class$java$util$BitSet;
        if (cls9 == null) {
            cls9 = class$("java.util.BitSet");
            class$java$util$BitSet = cls9;
        }
        hashSet.add(cls9);
        Class cls10 = class$java$nio$charset$Charset;
        if (cls10 == null) {
            cls10 = class$("java.nio.charset.Charset");
            class$java$nio$charset$Charset = cls10;
        }
        hashSet.add(cls10);
        Class cls11 = class$java$lang$Class;
        if (cls11 == null) {
            cls11 = class$("java.lang.Class");
            class$java$lang$Class = cls11;
        }
        hashSet.add(cls11);
        Class cls12 = class$java$util$Currency;
        if (cls12 == null) {
            cls12 = class$("java.util.Currency");
            class$java$util$Currency = cls12;
        }
        hashSet.add(cls12);
        Class cls13 = class$java$util$Date;
        if (cls13 == null) {
            cls13 = class$("java.util.Date");
            class$java$util$Date = cls13;
        }
        hashSet.add(cls13);
        Class cls14 = class$java$text$DecimalFormatSymbols;
        if (cls14 == null) {
            cls14 = class$("java.text.DecimalFormatSymbols");
            class$java$text$DecimalFormatSymbols = cls14;
        }
        hashSet.add(cls14);
        Class cls15 = class$java$io$File;
        if (cls15 == null) {
            cls15 = class$("java.io.File");
            class$java$io$File = cls15;
        }
        hashSet.add(cls15);
        Class cls16 = class$java$util$Locale;
        if (cls16 == null) {
            cls16 = class$("java.util.Locale");
            class$java$util$Locale = cls16;
        }
        hashSet.add(cls16);
        Class cls17 = class$java$lang$Object;
        if (cls17 == null) {
            cls17 = class$("java.lang.Object");
            class$java$lang$Object = cls17;
        }
        hashSet.add(cls17);
        Class cls18 = class$java$util$regex$Pattern;
        if (cls18 == null) {
            cls18 = class$("java.util.regex.Pattern");
            class$java$util$regex$Pattern = cls18;
        }
        hashSet.add(cls18);
        Class cls19 = class$java$lang$StackTraceElement;
        if (cls19 == null) {
            cls19 = class$("java.lang.StackTraceElement");
            class$java$lang$StackTraceElement = cls19;
        }
        hashSet.add(cls19);
        Class cls20 = class$java$lang$String;
        if (cls20 == null) {
            cls20 = class$("java.lang.String");
            class$java$lang$String = cls20;
        }
        hashSet.add(cls20);
        Class cls21 = class$java$lang$StringBuffer;
        if (cls21 == null) {
            cls21 = class$("java.lang.StringBuffer");
            class$java$lang$StringBuffer = cls21;
        }
        hashSet.add(cls21);
        hashSet.add(JVM.loadClassForName("java.lang.StringBuilder"));
        Class cls22 = class$java$net$URL;
        if (cls22 == null) {
            cls22 = class$("java.net.URL");
            class$java$net$URL = cls22;
        }
        hashSet.add(cls22);
        Class cls23 = class$java$net$URI;
        if (cls23 == null) {
            cls23 = class$("java.net.URI");
            class$java$net$URI = cls23;
        }
        hashSet.add(cls23);
        hashSet.add(JVM.loadClassForName("java.util.UUID"));
        if (JVM.isSQLAvailable()) {
            hashSet.add(JVM.loadClassForName("java.sql.Timestamp"));
            hashSet.add(JVM.loadClassForName("java.sql.Time"));
            hashSet.add(JVM.loadClassForName("java.sql.Date"));
        }
        if (JVM.isVersion(8)) {
            xStream.allowTypeHierarchy(JVM.loadClassForName("java.time.Clock"));
            hashSet.add(JVM.loadClassForName("java.time.Duration"));
            hashSet.add(JVM.loadClassForName("java.time.Instant"));
            hashSet.add(JVM.loadClassForName("java.time.LocalDate"));
            hashSet.add(JVM.loadClassForName("java.time.LocalDateTime"));
            hashSet.add(JVM.loadClassForName("java.time.LocalTime"));
            hashSet.add(JVM.loadClassForName("java.time.MonthDay"));
            hashSet.add(JVM.loadClassForName("java.time.OffsetDateTime"));
            hashSet.add(JVM.loadClassForName("java.time.OffsetTime"));
            hashSet.add(JVM.loadClassForName("java.time.Period"));
            hashSet.add(JVM.loadClassForName("java.time.Ser"));
            hashSet.add(JVM.loadClassForName("java.time.Year"));
            hashSet.add(JVM.loadClassForName("java.time.YearMonth"));
            hashSet.add(JVM.loadClassForName("java.time.ZonedDateTime"));
            xStream.allowTypeHierarchy(JVM.loadClassForName("java.time.ZoneId"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.HijrahDate"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.JapaneseDate"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.JapaneseEra"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.MinguoDate"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.ThaiBuddhistDate"));
            hashSet.add(JVM.loadClassForName("java.time.chrono.Ser"));
            xStream.allowTypeHierarchy(JVM.loadClassForName("java.time.chrono.Chronology"));
            hashSet.add(JVM.loadClassForName("java.time.temporal.ValueRange"));
            hashSet.add(JVM.loadClassForName("java.time.temporal.WeekFields"));
        }
        hashSet.remove(null);
        Iterator it = hashSet.iterator();
        Class[] clsArr = new Class[hashSet.size()];
        for (int i = 0; i < clsArr.length; i++) {
            clsArr[i] = (Class) it.next();
        }
        xStream.allowTypes(clsArr);
    }

    private void setupMappers() {
        Mapper mapper = this.mapper;
        Class cls = class$com$thoughtworks$xstream$mapper$PackageAliasingMapper;
        if (cls == null) {
            cls = class$("com.thoughtworks.xstream.mapper.PackageAliasingMapper");
            class$com$thoughtworks$xstream$mapper$PackageAliasingMapper = cls;
        }
        this.packageAliasingMapper = (PackageAliasingMapper) mapper.lookupMapperOfType(cls);
        Mapper mapper2 = this.mapper;
        Class cls2 = class$com$thoughtworks$xstream$mapper$ClassAliasingMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.ClassAliasingMapper");
            class$com$thoughtworks$xstream$mapper$ClassAliasingMapper = cls2;
        }
        this.classAliasingMapper = (ClassAliasingMapper) mapper2.lookupMapperOfType(cls2);
        Mapper mapper3 = this.mapper;
        Class cls3 = class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper;
        if (cls3 == null) {
            cls3 = class$("com.thoughtworks.xstream.mapper.ElementIgnoringMapper");
            class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper = cls3;
        }
        this.elementIgnoringMapper = (ElementIgnoringMapper) mapper3.lookupMapperOfType(cls3);
        Mapper mapper4 = this.mapper;
        Class cls4 = class$com$thoughtworks$xstream$mapper$FieldAliasingMapper;
        if (cls4 == null) {
            cls4 = class$("com.thoughtworks.xstream.mapper.FieldAliasingMapper");
            class$com$thoughtworks$xstream$mapper$FieldAliasingMapper = cls4;
        }
        this.fieldAliasingMapper = (FieldAliasingMapper) mapper4.lookupMapperOfType(cls4);
        Mapper mapper5 = this.mapper;
        Class cls5 = class$com$thoughtworks$xstream$mapper$AttributeMapper;
        if (cls5 == null) {
            cls5 = class$("com.thoughtworks.xstream.mapper.AttributeMapper");
            class$com$thoughtworks$xstream$mapper$AttributeMapper = cls5;
        }
        this.attributeMapper = (AttributeMapper) mapper5.lookupMapperOfType(cls5);
        Mapper mapper6 = this.mapper;
        Class cls6 = class$com$thoughtworks$xstream$mapper$AttributeAliasingMapper;
        if (cls6 == null) {
            cls6 = class$("com.thoughtworks.xstream.mapper.AttributeAliasingMapper");
            class$com$thoughtworks$xstream$mapper$AttributeAliasingMapper = cls6;
        }
        this.attributeAliasingMapper = (AttributeAliasingMapper) mapper6.lookupMapperOfType(cls6);
        Mapper mapper7 = this.mapper;
        Class cls7 = class$com$thoughtworks$xstream$mapper$SystemAttributeAliasingMapper;
        if (cls7 == null) {
            cls7 = class$("com.thoughtworks.xstream.mapper.SystemAttributeAliasingMapper");
            class$com$thoughtworks$xstream$mapper$SystemAttributeAliasingMapper = cls7;
        }
        this.systemAttributeAliasingMapper = (SystemAttributeAliasingMapper) mapper7.lookupMapperOfType(cls7);
        Mapper mapper8 = this.mapper;
        Class cls8 = class$com$thoughtworks$xstream$mapper$ImplicitCollectionMapper;
        if (cls8 == null) {
            cls8 = class$("com.thoughtworks.xstream.mapper.ImplicitCollectionMapper");
            class$com$thoughtworks$xstream$mapper$ImplicitCollectionMapper = cls8;
        }
        this.implicitCollectionMapper = (ImplicitCollectionMapper) mapper8.lookupMapperOfType(cls8);
        Mapper mapper9 = this.mapper;
        Class cls9 = class$com$thoughtworks$xstream$mapper$DefaultImplementationsMapper;
        if (cls9 == null) {
            cls9 = class$("com.thoughtworks.xstream.mapper.DefaultImplementationsMapper");
            class$com$thoughtworks$xstream$mapper$DefaultImplementationsMapper = cls9;
        }
        this.defaultImplementationsMapper = (DefaultImplementationsMapper) mapper9.lookupMapperOfType(cls9);
        Mapper mapper10 = this.mapper;
        Class cls10 = class$com$thoughtworks$xstream$mapper$ImmutableTypesMapper;
        if (cls10 == null) {
            cls10 = class$("com.thoughtworks.xstream.mapper.ImmutableTypesMapper");
            class$com$thoughtworks$xstream$mapper$ImmutableTypesMapper = cls10;
        }
        this.immutableTypesMapper = (ImmutableTypesMapper) mapper10.lookupMapperOfType(cls10);
        Mapper mapper11 = this.mapper;
        Class cls11 = class$com$thoughtworks$xstream$mapper$LocalConversionMapper;
        if (cls11 == null) {
            cls11 = class$("com.thoughtworks.xstream.mapper.LocalConversionMapper");
            class$com$thoughtworks$xstream$mapper$LocalConversionMapper = cls11;
        }
        this.localConversionMapper = (LocalConversionMapper) mapper11.lookupMapperOfType(cls11);
        Mapper mapper12 = this.mapper;
        Class cls12 = class$com$thoughtworks$xstream$mapper$SecurityMapper;
        if (cls12 == null) {
            cls12 = class$("com.thoughtworks.xstream.mapper.SecurityMapper");
            class$com$thoughtworks$xstream$mapper$SecurityMapper = cls12;
        }
        this.securityMapper = (SecurityMapper) mapper12.lookupMapperOfType(cls12);
        Mapper mapper13 = this.mapper;
        Class cls13 = class$com$thoughtworks$xstream$mapper$AnnotationConfiguration;
        if (cls13 == null) {
            cls13 = class$("com.thoughtworks.xstream.mapper.AnnotationConfiguration");
            class$com$thoughtworks$xstream$mapper$AnnotationConfiguration = cls13;
        }
        this.annotationConfiguration = (AnnotationConfiguration) mapper13.lookupMapperOfType(cls13);
    }

    public void addDefaultImplementation(Class cls, Class cls2) {
        DefaultImplementationsMapper defaultImplementationsMapper = this.defaultImplementationsMapper;
        if (defaultImplementationsMapper != null) {
            defaultImplementationsMapper.addDefaultImplementation(cls, cls2);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls3 = class$com$thoughtworks$xstream$mapper$DefaultImplementationsMapper;
        if (cls3 == null) {
            cls3 = class$("com.thoughtworks.xstream.mapper.DefaultImplementationsMapper");
            class$com$thoughtworks$xstream$mapper$DefaultImplementationsMapper = cls3;
        }
        stringBuffer.append(cls3.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void addImmutableType(Class cls) {
        addImmutableType(cls, true);
    }

    public void addImplicitArray(Class cls, String str) {
        addImplicitCollection(cls, str);
    }

    public void addImplicitCollection(Class cls, String str) {
        addImplicitCollection(cls, str, null, null);
    }

    public void addImplicitMap(Class cls, String str, Class cls2, String str2) {
        addImplicitMap(cls, str, null, cls2, str2);
    }

    public void addPermission(TypePermission typePermission) {
        SecurityMapper securityMapper = this.securityMapper;
        if (securityMapper != null) {
            this.securityInitialized = true;
            securityMapper.addPermission(typePermission);
        }
    }

    public void alias(String str, Class cls) {
        ClassAliasingMapper classAliasingMapper = this.classAliasingMapper;
        if (classAliasingMapper != null) {
            classAliasingMapper.addClassAlias(str, cls);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$ClassAliasingMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.ClassAliasingMapper");
            class$com$thoughtworks$xstream$mapper$ClassAliasingMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void aliasAttribute(String str, String str2) {
        AttributeAliasingMapper attributeAliasingMapper = this.attributeAliasingMapper;
        if (attributeAliasingMapper != null) {
            attributeAliasingMapper.addAliasFor(str2, str);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls = class$com$thoughtworks$xstream$mapper$AttributeAliasingMapper;
        if (cls == null) {
            cls = class$("com.thoughtworks.xstream.mapper.AttributeAliasingMapper");
            class$com$thoughtworks$xstream$mapper$AttributeAliasingMapper = cls;
        }
        stringBuffer.append(cls.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void aliasField(String str, Class cls, String str2) {
        FieldAliasingMapper fieldAliasingMapper = this.fieldAliasingMapper;
        if (fieldAliasingMapper != null) {
            fieldAliasingMapper.addFieldAlias(str, cls, str2);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$FieldAliasingMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.FieldAliasingMapper");
            class$com$thoughtworks$xstream$mapper$FieldAliasingMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void aliasPackage(String str, String str2) {
        PackageAliasingMapper packageAliasingMapper = this.packageAliasingMapper;
        if (packageAliasingMapper != null) {
            packageAliasingMapper.addPackageAlias(str, str2);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls = class$com$thoughtworks$xstream$mapper$PackageAliasingMapper;
        if (cls == null) {
            cls = class$("com.thoughtworks.xstream.mapper.PackageAliasingMapper");
            class$com$thoughtworks$xstream$mapper$PackageAliasingMapper = cls;
        }
        stringBuffer.append(cls.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void aliasSystemAttribute(String str, String str2) {
        SystemAttributeAliasingMapper systemAttributeAliasingMapper = this.systemAttributeAliasingMapper;
        if (systemAttributeAliasingMapper != null) {
            systemAttributeAliasingMapper.addAliasFor(str2, str);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls = class$com$thoughtworks$xstream$mapper$SystemAttributeAliasingMapper;
        if (cls == null) {
            cls = class$("com.thoughtworks.xstream.mapper.SystemAttributeAliasingMapper");
            class$com$thoughtworks$xstream$mapper$SystemAttributeAliasingMapper = cls;
        }
        stringBuffer.append(cls.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void aliasType(String str, Class cls) {
        ClassAliasingMapper classAliasingMapper = this.classAliasingMapper;
        if (classAliasingMapper != null) {
            classAliasingMapper.addTypeAlias(str, cls);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$ClassAliasingMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.ClassAliasingMapper");
            class$com$thoughtworks$xstream$mapper$ClassAliasingMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void allowTypeHierarchy(Class cls) {
        addPermission(new TypeHierarchyPermission(cls));
    }

    public void allowTypes(String[] strArr) {
        addPermission(new ExplicitTypePermission(strArr));
    }

    public void allowTypesByRegExp(String[] strArr) {
        addPermission(new RegExpTypePermission(strArr));
    }

    public void allowTypesByWildcard(String[] strArr) {
        addPermission(new WildcardTypePermission(strArr));
    }

    public void autodetectAnnotations(boolean z) {
        AnnotationConfiguration annotationConfiguration = this.annotationConfiguration;
        if (annotationConfiguration != null) {
            annotationConfiguration.autodetectAnnotations(z);
        }
    }

    public ObjectInputStream createObjectInputStream(Reader reader) throws IOException {
        return createObjectInputStream(this.hierarchicalStreamDriver.createReader(reader));
    }

    public ObjectOutputStream createObjectOutputStream(Writer writer) throws IOException {
        return createObjectOutputStream(this.hierarchicalStreamDriver.createWriter(writer), "object-stream");
    }

    public void denyPermission(TypePermission typePermission) {
        addPermission(new NoPermission(typePermission));
    }

    public void denyTypeHierarchy(Class cls) {
        denyPermission(new TypeHierarchyPermission(cls));
    }

    public void denyTypes(String[] strArr) {
        denyPermission(new ExplicitTypePermission(strArr));
    }

    public void denyTypesByRegExp(String[] strArr) {
        denyPermission(new RegExpTypePermission(strArr));
    }

    public void denyTypesByWildcard(String[] strArr) {
        denyPermission(new WildcardTypePermission(strArr));
    }

    public Object fromXML(String str) {
        return fromXML(new StringReader(str));
    }

    public ClassLoader getClassLoader() {
        return this.classLoaderReference.getReference();
    }

    public ClassLoaderReference getClassLoaderReference() {
        return this.classLoaderReference;
    }

    public ConverterLookup getConverterLookup() {
        return this.converterLookup;
    }

    public Mapper getMapper() {
        return this.mapper;
    }

    public ReflectionProvider getReflectionProvider() {
        return this.reflectionProvider;
    }

    public void ignoreUnknownElements() {
        ignoreUnknownElements(IGNORE_ALL);
    }

    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter) {
        marshal(obj, hierarchicalStreamWriter, null);
    }

    public DataHolder newDataHolder() {
        return new MapBackedDataHolder();
    }

    public void omitField(Class cls, String str) {
        ElementIgnoringMapper elementIgnoringMapper = this.elementIgnoringMapper;
        if (elementIgnoringMapper != null) {
            elementIgnoringMapper.omitField(cls, str);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.ElementIgnoringMapper");
            class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void processAnnotations(Class[] clsArr) {
        AnnotationConfiguration annotationConfiguration = this.annotationConfiguration;
        if (annotationConfiguration == null) {
            throw new com.thoughtworks.xstream.InitializationException("No com.thoughtworks.xstream.mapper.AnnotationMapper available");
        }
        annotationConfiguration.processAnnotations(clsArr);
    }

    public void registerConverter(Converter converter) {
        registerConverter(converter, 0);
    }

    public void registerLocalConverter(Class cls, String str, Converter converter) {
        LocalConversionMapper localConversionMapper = this.localConversionMapper;
        if (localConversionMapper != null) {
            localConversionMapper.registerLocalConverter(cls, str, converter);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$LocalConversionMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.LocalConversionMapper");
            class$com$thoughtworks$xstream$mapper$LocalConversionMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void setClassLoader(ClassLoader classLoader) {
        this.classLoaderReference.setReference(classLoader);
    }

    public void setMarshallingStrategy(MarshallingStrategy marshallingStrategy) {
        this.marshallingStrategy = marshallingStrategy;
    }

    public void setMode(int i) {
        switch (i) {
            case 1001:
                setMarshallingStrategy(new TreeMarshallingStrategy());
                return;
            case 1002:
                setMarshallingStrategy(new ReferenceByIdMarshallingStrategy());
                return;
            case 1003:
                setMarshallingStrategy(new ReferenceByXPathMarshallingStrategy(ReferenceByXPathMarshallingStrategy.RELATIVE));
                return;
            case 1004:
                setMarshallingStrategy(new ReferenceByXPathMarshallingStrategy(ReferenceByXPathMarshallingStrategy.ABSOLUTE));
                return;
            case 1005:
                setMarshallingStrategy(new ReferenceByXPathMarshallingStrategy(ReferenceByXPathMarshallingStrategy.RELATIVE | ReferenceByXPathMarshallingStrategy.SINGLE_NODE));
                return;
            case 1006:
                setMarshallingStrategy(new ReferenceByXPathMarshallingStrategy(ReferenceByXPathMarshallingStrategy.ABSOLUTE | ReferenceByXPathMarshallingStrategy.SINGLE_NODE));
                return;
            default:
                StringBuffer stringBuffer = new StringBuffer();
                stringBuffer.append("Unknown mode : ");
                stringBuffer.append(i);
                throw new IllegalArgumentException(stringBuffer.toString());
        }
    }

    protected void setupAliases() {
        if (this.classAliasingMapper == null) {
            return;
        }
        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;
        }
        alias("null", cls);
        Class cls2 = class$java$lang$Integer;
        if (cls2 == null) {
            cls2 = class$("java.lang.Integer");
            class$java$lang$Integer = cls2;
        }
        alias("int", cls2);
        Class cls3 = class$java$lang$Float;
        if (cls3 == null) {
            cls3 = class$("java.lang.Float");
            class$java$lang$Float = cls3;
        }
        alias("float", cls3);
        Class cls4 = class$java$lang$Double;
        if (cls4 == null) {
            cls4 = class$("java.lang.Double");
            class$java$lang$Double = cls4;
        }
        alias("double", cls4);
        Class cls5 = class$java$lang$Long;
        if (cls5 == null) {
            cls5 = class$("java.lang.Long");
            class$java$lang$Long = cls5;
        }
        alias("long", cls5);
        Class cls6 = class$java$lang$Short;
        if (cls6 == null) {
            cls6 = class$("java.lang.Short");
            class$java$lang$Short = cls6;
        }
        alias("short", cls6);
        Class cls7 = class$java$lang$Character;
        if (cls7 == null) {
            cls7 = class$("java.lang.Character");
            class$java$lang$Character = cls7;
        }
        alias("char", cls7);
        Class cls8 = class$java$lang$Byte;
        if (cls8 == null) {
            cls8 = class$("java.lang.Byte");
            class$java$lang$Byte = cls8;
        }
        alias("byte", cls8);
        Class cls9 = class$java$lang$Boolean;
        if (cls9 == null) {
            cls9 = class$("java.lang.Boolean");
            class$java$lang$Boolean = cls9;
        }
        alias("boolean", cls9);
        Class cls10 = class$java$lang$Number;
        if (cls10 == null) {
            cls10 = class$("java.lang.Number");
            class$java$lang$Number = cls10;
        }
        alias("number", cls10);
        Class cls11 = class$java$lang$Object;
        if (cls11 == null) {
            cls11 = class$("java.lang.Object");
            class$java$lang$Object = cls11;
        }
        alias("object", cls11);
        Class cls12 = class$java$math$BigInteger;
        if (cls12 == null) {
            cls12 = class$("java.math.BigInteger");
            class$java$math$BigInteger = cls12;
        }
        alias("big-int", cls12);
        Class cls13 = class$java$math$BigDecimal;
        if (cls13 == null) {
            cls13 = class$("java.math.BigDecimal");
            class$java$math$BigDecimal = cls13;
        }
        alias("big-decimal", cls13);
        Class cls14 = class$java$lang$StringBuffer;
        if (cls14 == null) {
            cls14 = class$("java.lang.StringBuffer");
            class$java$lang$StringBuffer = cls14;
        }
        alias("string-buffer", cls14);
        Class cls15 = class$java$lang$String;
        if (cls15 == null) {
            cls15 = class$("java.lang.String");
            class$java$lang$String = cls15;
        }
        alias("string", cls15);
        Class cls16 = class$java$lang$Class;
        if (cls16 == null) {
            cls16 = class$("java.lang.Class");
            class$java$lang$Class = cls16;
        }
        alias("java-class", cls16);
        Class cls17 = class$java$lang$reflect$Method;
        if (cls17 == null) {
            cls17 = class$("java.lang.reflect.Method");
            class$java$lang$reflect$Method = cls17;
        }
        alias("method", cls17);
        Class cls18 = class$java$lang$reflect$Constructor;
        if (cls18 == null) {
            cls18 = class$("java.lang.reflect.Constructor");
            class$java$lang$reflect$Constructor = cls18;
        }
        alias("constructor", cls18);
        Class cls19 = class$java$lang$reflect$Field;
        if (cls19 == null) {
            cls19 = class$("java.lang.reflect.Field");
            class$java$lang$reflect$Field = cls19;
        }
        alias("field", cls19);
        Class cls20 = class$java$util$Date;
        if (cls20 == null) {
            cls20 = class$("java.util.Date");
            class$java$util$Date = cls20;
        }
        alias("date", cls20);
        Class cls21 = class$java$net$URI;
        if (cls21 == null) {
            cls21 = class$("java.net.URI");
            class$java$net$URI = cls21;
        }
        alias("uri", cls21);
        Class cls22 = class$java$net$URL;
        if (cls22 == null) {
            cls22 = class$("java.net.URL");
            class$java$net$URL = cls22;
        }
        alias("url", cls22);
        Class cls23 = class$java$util$BitSet;
        if (cls23 == null) {
            cls23 = class$("java.util.BitSet");
            class$java$util$BitSet = cls23;
        }
        alias("bit-set", cls23);
        Class cls24 = class$java$util$Map;
        if (cls24 == null) {
            cls24 = class$("java.util.Map");
            class$java$util$Map = cls24;
        }
        alias("map", cls24);
        Class cls25 = class$java$util$Map$Entry;
        if (cls25 == null) {
            cls25 = class$("java.util.Map$Entry");
            class$java$util$Map$Entry = cls25;
        }
        alias("entry", cls25);
        Class cls26 = class$java$util$Properties;
        if (cls26 == null) {
            cls26 = class$("java.util.Properties");
            class$java$util$Properties = cls26;
        }
        alias("properties", cls26);
        Class cls27 = class$java$util$List;
        if (cls27 == null) {
            cls27 = class$("java.util.List");
            class$java$util$List = cls27;
        }
        alias("list", cls27);
        Class cls28 = class$java$util$Set;
        if (cls28 == null) {
            cls28 = class$("java.util.Set");
            class$java$util$Set = cls28;
        }
        alias("set", cls28);
        Class cls29 = class$java$util$SortedSet;
        if (cls29 == null) {
            cls29 = class$("java.util.SortedSet");
            class$java$util$SortedSet = cls29;
        }
        alias("sorted-set", cls29);
        Class cls30 = class$java$util$LinkedList;
        if (cls30 == null) {
            cls30 = class$("java.util.LinkedList");
            class$java$util$LinkedList = cls30;
        }
        alias("linked-list", cls30);
        Class cls31 = class$java$util$Vector;
        if (cls31 == null) {
            cls31 = class$("java.util.Vector");
            class$java$util$Vector = cls31;
        }
        alias("vector", cls31);
        Class cls32 = class$java$util$TreeMap;
        if (cls32 == null) {
            cls32 = class$("java.util.TreeMap");
            class$java$util$TreeMap = cls32;
        }
        alias("tree-map", cls32);
        Class cls33 = class$java$util$TreeSet;
        if (cls33 == null) {
            cls33 = class$("java.util.TreeSet");
            class$java$util$TreeSet = cls33;
        }
        alias("tree-set", cls33);
        Class cls34 = class$java$util$Hashtable;
        if (cls34 == null) {
            cls34 = class$("java.util.Hashtable");
            class$java$util$Hashtable = cls34;
        }
        alias("hashtable", cls34);
        alias("empty-list", Collections.EMPTY_LIST.getClass());
        alias("empty-map", Collections.EMPTY_MAP.getClass());
        alias("empty-set", Collections.EMPTY_SET.getClass());
        alias("singleton-list", Collections.singletonList(this).getClass());
        alias("singleton-map", Collections.singletonMap(this, null).getClass());
        alias("singleton-set", Collections.singleton(this).getClass());
        if (JVM.isAWTAvailable()) {
            alias("awt-color", JVM.loadClassForName("java.awt.Color", false));
            alias("awt-font", JVM.loadClassForName("java.awt.Font", false));
            alias("awt-text-attribute", JVM.loadClassForName("java.awt.font.TextAttribute"));
        }
        Class loadClassForName = JVM.loadClassForName("javax.activation.ActivationDataFlavor");
        if (loadClassForName != null) {
            alias("activation-data-flavor", loadClassForName);
        }
        if (JVM.isSQLAvailable()) {
            alias("sql-timestamp", JVM.loadClassForName("java.sql.Timestamp"));
            alias("sql-time", JVM.loadClassForName("java.sql.Time"));
            alias("sql-date", JVM.loadClassForName("java.sql.Date"));
        }
        Class cls35 = class$java$io$File;
        if (cls35 == null) {
            cls35 = class$("java.io.File");
            class$java$io$File = cls35;
        }
        alias("file", cls35);
        Class cls36 = class$java$util$Locale;
        if (cls36 == null) {
            cls36 = class$("java.util.Locale");
            class$java$util$Locale = cls36;
        }
        alias("locale", cls36);
        Class cls37 = class$java$util$Calendar;
        if (cls37 == null) {
            cls37 = class$("java.util.Calendar");
            class$java$util$Calendar = cls37;
        }
        alias("gregorian-calendar", cls37);
        if (JVM.isVersion(4)) {
            aliasDynamically("auth-subject", "javax.security.auth.Subject");
            alias("linked-hash-map", JVM.loadClassForName("java.util.LinkedHashMap"));
            alias("linked-hash-set", JVM.loadClassForName("java.util.LinkedHashSet"));
            alias("trace", JVM.loadClassForName("java.lang.StackTraceElement"));
            alias(InAppPurchaseMetaData.KEY_CURRENCY, JVM.loadClassForName("java.util.Currency"));
            aliasType("charset", JVM.loadClassForName("java.nio.charset.Charset"));
        }
        if (JVM.isVersion(5)) {
            aliasDynamically("xml-duration", "javax.xml.datatype.Duration");
            alias("concurrent-hash-map", JVM.loadClassForName("java.util.concurrent.ConcurrentHashMap"));
            alias("enum-set", JVM.loadClassForName("java.util.EnumSet"));
            alias("enum-map", JVM.loadClassForName("java.util.EnumMap"));
            alias("string-builder", JVM.loadClassForName("java.lang.StringBuilder"));
            alias(BuildStepFragment.UUID, JVM.loadClassForName("java.util.UUID"));
        }
        if (JVM.isVersion(7)) {
            aliasType(FileDownloadModel.PATH, JVM.loadClassForName("java.nio.file.Path"));
        }
        if (JVM.isVersion(8)) {
            alias("fixed-clock", JVM.loadClassForName("java.time.Clock$FixedClock"));
            alias("offset-clock", JVM.loadClassForName("java.time.Clock$OffsetClock"));
            alias("system-clock", JVM.loadClassForName("java.time.Clock$SystemClock"));
            alias("tick-clock", JVM.loadClassForName("java.time.Clock$TickClock"));
            alias("day-of-week", JVM.loadClassForName("java.time.DayOfWeek"));
            alias("duration", JVM.loadClassForName("java.time.Duration"));
            alias("instant", JVM.loadClassForName("java.time.Instant"));
            alias("local-date", JVM.loadClassForName("java.time.LocalDate"));
            alias("local-date-time", JVM.loadClassForName("java.time.LocalDateTime"));
            alias("local-time", JVM.loadClassForName("java.time.LocalTime"));
            alias("month", JVM.loadClassForName("java.time.Month"));
            alias("month-day", JVM.loadClassForName("java.time.MonthDay"));
            alias("offset-date-time", JVM.loadClassForName("java.time.OffsetDateTime"));
            alias("offset-time", JVM.loadClassForName("java.time.OffsetTime"));
            alias("period", JVM.loadClassForName("java.time.Period"));
            alias("year", JVM.loadClassForName("java.time.Year"));
            alias("year-month", JVM.loadClassForName("java.time.YearMonth"));
            alias("zoned-date-time", JVM.loadClassForName("java.time.ZonedDateTime"));
            aliasType("zone-id", JVM.loadClassForName("java.time.ZoneId"));
            aliasType("chronology", JVM.loadClassForName("java.time.chrono.Chronology"));
            alias("hijrah-date", JVM.loadClassForName("java.time.chrono.HijrahDate"));
            alias("hijrah-era", JVM.loadClassForName("java.time.chrono.HijrahEra"));
            alias("japanese-date", JVM.loadClassForName("java.time.chrono.JapaneseDate"));
            alias("japanese-era", JVM.loadClassForName("java.time.chrono.JapaneseEra"));
            alias("minguo-date", JVM.loadClassForName("java.time.chrono.MinguoDate"));
            alias("minguo-era", JVM.loadClassForName("java.time.chrono.MinguoEra"));
            alias("thai-buddhist-date", JVM.loadClassForName("java.time.chrono.ThaiBuddhistDate"));
            alias("thai-buddhist-era", JVM.loadClassForName("java.time.chrono.ThaiBuddhistEra"));
            alias("chrono-field", JVM.loadClassForName("java.time.temporal.ChronoField"));
            alias("chrono-unit", JVM.loadClassForName("java.time.temporal.ChronoUnit"));
            alias("iso-field", JVM.loadClassForName("java.time.temporal.IsoFields$Field"));
            alias("iso-unit", JVM.loadClassForName("java.time.temporal.IsoFields$Unit"));
            alias("julian-field", JVM.loadClassForName("java.time.temporal.JulianFields$Field"));
            alias("temporal-value-range", JVM.loadClassForName("java.time.temporal.ValueRange"));
            alias("week-fields", JVM.loadClassForName("java.time.temporal.WeekFields"));
        }
        if (JVM.loadClassForName("java.lang.invoke.SerializedLambda") != null) {
            aliasDynamically("serialized-lambda", "java.lang.invoke.SerializedLambda");
        }
    }

    protected void setupConverters() {
        registerConverter(new ReflectionConverter(this.mapper, this.reflectionProvider), -20);
        registerConverter(new SerializableConverter(this.mapper, this.reflectionProvider, this.classLoaderReference), -10);
        registerConverter(new ExternalizableConverter(this.mapper, this.classLoaderReference), -10);
        registerConverter(new InternalBlackList(), -10);
        registerConverter(new NullConverter(), PRIORITY_VERY_HIGH);
        registerConverter(new IntConverter(), 0);
        registerConverter(new FloatConverter(), 0);
        registerConverter(new DoubleConverter(), 0);
        registerConverter(new LongConverter(), 0);
        registerConverter(new ShortConverter(), 0);
        registerConverter((Converter) new CharConverter(), 0);
        registerConverter(new BooleanConverter(), 0);
        registerConverter(new ByteConverter(), 0);
        registerConverter(new StringConverter(), 0);
        registerConverter(new StringBufferConverter(), 0);
        registerConverter(new DateConverter(), 0);
        registerConverter(new BitSetConverter(), 0);
        registerConverter(new URIConverter(), 0);
        registerConverter(new URLConverter(), 0);
        registerConverter(new BigIntegerConverter(), 0);
        registerConverter(new BigDecimalConverter(), 0);
        registerConverter(new ArrayConverter(this.mapper), 0);
        registerConverter(new CharArrayConverter(), 0);
        registerConverter(new CollectionConverter(this.mapper), 0);
        registerConverter(new MapConverter(this.mapper), 0);
        registerConverter(new TreeMapConverter(this.mapper), 0);
        registerConverter(new TreeSetConverter(this.mapper), 0);
        registerConverter(new SingletonCollectionConverter(this.mapper), 0);
        registerConverter(new SingletonMapConverter(this.mapper), 0);
        registerConverter(new PropertiesConverter(), 0);
        registerConverter((Converter) new EncodedByteArrayConverter(), 0);
        registerConverter(new FileConverter(), 0);
        if (JVM.isSQLAvailable()) {
            registerConverter(new SqlTimestampConverter(), 0);
            registerConverter(new SqlTimeConverter(), 0);
            registerConverter(new SqlDateConverter(), 0);
        }
        registerConverter(new DynamicProxyConverter(this.mapper, this.classLoaderReference), 0);
        registerConverter(new JavaClassConverter(this.classLoaderReference), 0);
        registerConverter(new JavaMethodConverter(this.classLoaderReference), 0);
        registerConverter(new JavaFieldConverter(this.classLoaderReference), 0);
        if (JVM.isAWTAvailable()) {
            registerConverter(new FontConverter(this.mapper), 0);
            registerConverter(new ColorConverter(), 0);
            registerConverter(new TextAttributeConverter(), 0);
        }
        if (JVM.isSwingAvailable()) {
            registerConverter(new LookAndFeelConverter(this.mapper, this.reflectionProvider), 0);
        }
        registerConverter(new LocaleConverter(), 0);
        registerConverter(new GregorianCalendarConverter(), 0);
        if (JVM.isVersion(4)) {
            Class[] clsArr = new Class[1];
            Class cls = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls == null) {
                cls = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls;
            }
            clsArr[0] = cls;
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.SubjectConverter", 0, clsArr, new Object[]{this.mapper});
            Class[] clsArr2 = new Class[1];
            Class cls2 = class$com$thoughtworks$xstream$converters$ConverterLookup;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.converters.ConverterLookup");
                class$com$thoughtworks$xstream$converters$ConverterLookup = cls2;
            }
            clsArr2[0] = cls2;
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.ThrowableConverter", 0, clsArr2, new Object[]{this.converterLookup});
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.StackTraceElementConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.CurrencyConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.RegexPatternConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.CharsetConverter", 0, null, null);
        }
        if (JVM.isVersion(5)) {
            if (JVM.loadClassForName("javax.xml.datatype.Duration") != null) {
                registerConverterDynamically("com.thoughtworks.xstream.converters.extended.DurationConverter", 0, null, null);
            }
            registerConverterDynamically("com.thoughtworks.xstream.converters.enums.EnumConverter", 0, null, null);
            Class[] clsArr3 = new Class[1];
            Class cls3 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls3 == null) {
                cls3 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls3;
            }
            clsArr3[0] = cls3;
            registerConverterDynamically("com.thoughtworks.xstream.converters.enums.EnumSetConverter", 0, clsArr3, new Object[]{this.mapper});
            Class[] clsArr4 = new Class[1];
            Class cls4 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls4 == null) {
                cls4 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls4;
            }
            clsArr4[0] = cls4;
            registerConverterDynamically("com.thoughtworks.xstream.converters.enums.EnumMapConverter", 0, clsArr4, new Object[]{this.mapper});
            registerConverterDynamically("com.thoughtworks.xstream.converters.basic.StringBuilderConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.basic.UUIDConverter", 0, null, null);
        }
        if (JVM.loadClassForName("javax.activation.ActivationDataFlavor") != null) {
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.ActivationDataFlavorConverter", 0, null, null);
        }
        if (JVM.isVersion(7)) {
            registerConverterDynamically("com.thoughtworks.xstream.converters.extended.PathConverter", 0, null, null);
        }
        if (JVM.isVersion(8)) {
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.ChronologyConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.DurationConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.HijrahDateConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.JapaneseDateConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.JapaneseEraConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.InstantConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.LocalDateConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.LocalDateTimeConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.LocalTimeConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.MinguoDateConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.MonthDayConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.OffsetDateTimeConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.OffsetTimeConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.PeriodConverter", 0, null, null);
            Class[] clsArr5 = new Class[1];
            Class cls5 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls5 == null) {
                cls5 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls5;
            }
            clsArr5[0] = cls5;
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.SystemClockConverter", 0, clsArr5, new Object[]{this.mapper});
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.ThaiBuddhistDateConverter", 0, null, null);
            Class[] clsArr6 = new Class[1];
            Class cls6 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls6 == null) {
                cls6 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls6;
            }
            clsArr6[0] = cls6;
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.ValueRangeConverter", 0, clsArr6, new Object[]{this.mapper});
            Class[] clsArr7 = new Class[1];
            Class cls7 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls7 == null) {
                cls7 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls7;
            }
            clsArr7[0] = cls7;
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.WeekFieldsConverter", 0, clsArr7, new Object[]{this.mapper});
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.YearConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.YearMonthConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.ZonedDateTimeConverter", 0, null, null);
            registerConverterDynamically("com.thoughtworks.xstream.converters.time.ZoneIdConverter", 0, null, null);
            Class[] clsArr8 = new Class[3];
            Class cls8 = class$com$thoughtworks$xstream$mapper$Mapper;
            if (cls8 == null) {
                cls8 = class$("com.thoughtworks.xstream.mapper.Mapper");
                class$com$thoughtworks$xstream$mapper$Mapper = cls8;
            }
            clsArr8[0] = cls8;
            Class cls9 = class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider;
            if (cls9 == null) {
                cls9 = class$("com.thoughtworks.xstream.converters.reflection.ReflectionProvider");
                class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider = cls9;
            }
            clsArr8[1] = cls9;
            Class cls10 = class$com$thoughtworks$xstream$core$ClassLoaderReference;
            if (cls10 == null) {
                cls10 = class$("com.thoughtworks.xstream.core.ClassLoaderReference");
                class$com$thoughtworks$xstream$core$ClassLoaderReference = cls10;
            }
            clsArr8[2] = cls10;
            registerConverterDynamically("com.thoughtworks.xstream.converters.reflection.LambdaConverter", 0, clsArr8, new Object[]{this.mapper, this.reflectionProvider, this.classLoaderReference});
        }
        registerConverter(new SelfStreamingInstanceChecker(this.converterLookup, this), 0);
    }

    protected void setupDefaultImplementations() {
        if (this.defaultImplementationsMapper == null) {
            return;
        }
        Class cls = class$java$util$HashMap;
        if (cls == null) {
            cls = class$("java.util.HashMap");
            class$java$util$HashMap = cls;
        }
        Class cls2 = class$java$util$Map;
        if (cls2 == null) {
            cls2 = class$("java.util.Map");
            class$java$util$Map = cls2;
        }
        addDefaultImplementation(cls, cls2);
        Class cls3 = class$java$util$ArrayList;
        if (cls3 == null) {
            cls3 = class$("java.util.ArrayList");
            class$java$util$ArrayList = cls3;
        }
        Class cls4 = class$java$util$List;
        if (cls4 == null) {
            cls4 = class$("java.util.List");
            class$java$util$List = cls4;
        }
        addDefaultImplementation(cls3, cls4);
        Class cls5 = class$java$util$HashSet;
        if (cls5 == null) {
            cls5 = class$("java.util.HashSet");
            class$java$util$HashSet = cls5;
        }
        Class cls6 = class$java$util$Set;
        if (cls6 == null) {
            cls6 = class$("java.util.Set");
            class$java$util$Set = cls6;
        }
        addDefaultImplementation(cls5, cls6);
        Class cls7 = class$java$util$TreeSet;
        if (cls7 == null) {
            cls7 = class$("java.util.TreeSet");
            class$java$util$TreeSet = cls7;
        }
        Class cls8 = class$java$util$SortedSet;
        if (cls8 == null) {
            cls8 = class$("java.util.SortedSet");
            class$java$util$SortedSet = cls8;
        }
        addDefaultImplementation(cls7, cls8);
        Class cls9 = class$java$util$GregorianCalendar;
        if (cls9 == null) {
            cls9 = class$("java.util.GregorianCalendar");
            class$java$util$GregorianCalendar = cls9;
        }
        Class cls10 = class$java$util$Calendar;
        if (cls10 == null) {
            cls10 = class$("java.util.Calendar");
            class$java$util$Calendar = cls10;
        }
        addDefaultImplementation(cls9, cls10);
    }

    protected void setupImmutableTypes() {
        Class loadClassForName;
        Class<?> cls;
        Class<?> cls2;
        Object invoke;
        if (this.immutableTypesMapper == null) {
            return;
        }
        addImmutableType(Boolean.TYPE, false);
        Class cls3 = class$java$lang$Boolean;
        if (cls3 == null) {
            cls3 = class$("java.lang.Boolean");
            class$java$lang$Boolean = cls3;
        }
        addImmutableType(cls3, false);
        addImmutableType(Byte.TYPE, false);
        Class cls4 = class$java$lang$Byte;
        if (cls4 == null) {
            cls4 = class$("java.lang.Byte");
            class$java$lang$Byte = cls4;
        }
        addImmutableType(cls4, false);
        addImmutableType(Character.TYPE, false);
        Class cls5 = class$java$lang$Character;
        if (cls5 == null) {
            cls5 = class$("java.lang.Character");
            class$java$lang$Character = cls5;
        }
        addImmutableType(cls5, false);
        addImmutableType(Double.TYPE, false);
        Class cls6 = class$java$lang$Double;
        if (cls6 == null) {
            cls6 = class$("java.lang.Double");
            class$java$lang$Double = cls6;
        }
        addImmutableType(cls6, false);
        addImmutableType(Float.TYPE, false);
        Class cls7 = class$java$lang$Float;
        if (cls7 == null) {
            cls7 = class$("java.lang.Float");
            class$java$lang$Float = cls7;
        }
        addImmutableType(cls7, false);
        addImmutableType(Integer.TYPE, false);
        Class cls8 = class$java$lang$Integer;
        if (cls8 == null) {
            cls8 = class$("java.lang.Integer");
            class$java$lang$Integer = cls8;
        }
        addImmutableType(cls8, false);
        addImmutableType(Long.TYPE, false);
        Class cls9 = class$java$lang$Long;
        if (cls9 == null) {
            cls9 = class$("java.lang.Long");
            class$java$lang$Long = cls9;
        }
        addImmutableType(cls9, false);
        addImmutableType(Short.TYPE, false);
        Class cls10 = class$java$lang$Short;
        if (cls10 == null) {
            cls10 = class$("java.lang.Short");
            class$java$lang$Short = cls10;
        }
        addImmutableType(cls10, false);
        Class cls11 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
        if (cls11 == null) {
            cls11 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls11;
        }
        addImmutableType(cls11, false);
        Class cls12 = class$java$math$BigDecimal;
        if (cls12 == null) {
            cls12 = class$("java.math.BigDecimal");
            class$java$math$BigDecimal = cls12;
        }
        addImmutableType(cls12, false);
        Class cls13 = class$java$math$BigInteger;
        if (cls13 == null) {
            cls13 = class$("java.math.BigInteger");
            class$java$math$BigInteger = cls13;
        }
        addImmutableType(cls13, false);
        Class cls14 = class$java$lang$String;
        if (cls14 == null) {
            cls14 = class$("java.lang.String");
            class$java$lang$String = cls14;
        }
        addImmutableType(cls14, false);
        Class cls15 = class$java$net$URL;
        if (cls15 == null) {
            cls15 = class$("java.net.URL");
            class$java$net$URL = cls15;
        }
        addImmutableType(cls15, false);
        Class cls16 = class$java$io$File;
        if (cls16 == null) {
            cls16 = class$("java.io.File");
            class$java$io$File = cls16;
        }
        addImmutableType(cls16, false);
        Class cls17 = class$java$lang$Class;
        if (cls17 == null) {
            cls17 = class$("java.lang.Class");
            class$java$lang$Class = cls17;
        }
        addImmutableType(cls17, false);
        if (JVM.isVersion(7) && (loadClassForName = JVM.loadClassForName("java.nio.file.Paths")) != null) {
            try {
                Class<?>[] clsArr = new Class[2];
                if (class$java$lang$String == null) {
                    cls = class$("java.lang.String");
                    class$java$lang$String = cls;
                } else {
                    cls = class$java$lang$String;
                }
                clsArr[0] = cls;
                if (array$Ljava$lang$String == null) {
                    cls2 = class$("[Ljava.lang.String;");
                    array$Ljava$lang$String = cls2;
                } else {
                    cls2 = array$Ljava$lang$String;
                }
                clsArr[1] = cls2;
                Method declaredMethod = loadClassForName.getDeclaredMethod("get", clsArr);
                if (declaredMethod != null && (invoke = declaredMethod.invoke(null, ".", new String[0])) != null) {
                    addImmutableType(invoke.getClass(), false);
                }
            } catch (IllegalAccessException | NoSuchMethodException | SecurityException | InvocationTargetException unused) {
            }
        }
        if (JVM.isAWTAvailable()) {
            addImmutableTypeDynamically("java.awt.font.TextAttribute", false);
        }
        if (JVM.isVersion(4)) {
            addImmutableTypeDynamically("java.nio.charset.Charset", true);
            addImmutableTypeDynamically("java.util.Currency", true);
        }
        if (JVM.isVersion(5)) {
            addImmutableTypeDynamically("java.util.UUID", true);
        }
        Class cls18 = class$java$net$URI;
        if (cls18 == null) {
            cls18 = class$("java.net.URI");
            class$java$net$URI = cls18;
        }
        addImmutableType(cls18, true);
        addImmutableType(Collections.EMPTY_LIST.getClass(), true);
        addImmutableType(Collections.EMPTY_SET.getClass(), true);
        addImmutableType(Collections.EMPTY_MAP.getClass(), true);
        if (JVM.isVersion(8)) {
            addImmutableTypeDynamically("java.time.Duration", false);
            addImmutableTypeDynamically("java.time.Instant", false);
            addImmutableTypeDynamically("java.time.LocalDate", false);
            addImmutableTypeDynamically("java.time.LocalDateTime", false);
            addImmutableTypeDynamically("java.time.LocalTime", false);
            addImmutableTypeDynamically("java.time.MonthDay", false);
            addImmutableTypeDynamically("java.time.OffsetDateTime", false);
            addImmutableTypeDynamically("java.time.OffsetTime", false);
            addImmutableTypeDynamically("java.time.Period", false);
            addImmutableTypeDynamically("java.time.Year", false);
            addImmutableTypeDynamically("java.time.YearMonth", false);
            addImmutableTypeDynamically("java.time.ZonedDateTime", false);
            addImmutableTypeDynamically("java.time.ZoneId", false);
            addImmutableTypeDynamically("java.time.ZoneOffset", false);
            addImmutableTypeDynamically("java.time.ZoneRegion", false);
            addImmutableTypeDynamically("java.time.chrono.HijrahChronology", false);
            addImmutableTypeDynamically("java.time.chrono.HijrahDate", false);
            addImmutableTypeDynamically("java.time.chrono.IsoChronology", false);
            addImmutableTypeDynamically("java.time.chrono.JapaneseChronology", false);
            addImmutableTypeDynamically("java.time.chrono.JapaneseDate", false);
            addImmutableTypeDynamically("java.time.chrono.JapaneseEra", false);
            addImmutableTypeDynamically("java.time.chrono.MinguoChronology", false);
            addImmutableTypeDynamically("java.time.chrono.MinguoDate", false);
            addImmutableTypeDynamically("java.time.chrono.ThaiBuddhistChronology", false);
            addImmutableTypeDynamically("java.time.chrono.ThaiBuddhistDate", false);
            addImmutableTypeDynamically("java.time.temporal.IsoFields$Field", false);
            addImmutableTypeDynamically("java.time.temporal.IsoFields$Unit", false);
            addImmutableTypeDynamically("java.time.temporal.JulianFields$Field", false);
        }
    }

    protected void setupSecurity() {
        if (this.securityMapper == null) {
            return;
        }
        addPermission(AnyTypePermission.ANY);
        this.securityInitialized = false;
    }

    public String toXML(Object obj) {
        StringWriter stringWriter = new StringWriter();
        toXML(obj, stringWriter);
        return stringWriter.toString();
    }

    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader) {
        return unmarshal(hierarchicalStreamReader, null, null);
    }

    public void useAttributeFor(String str, Class cls) {
        AttributeMapper attributeMapper = this.attributeMapper;
        if (attributeMapper != null) {
            attributeMapper.addAttributeFor(str, cls);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$AttributeMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.AttributeMapper");
            class$com$thoughtworks$xstream$mapper$AttributeMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    protected boolean useXStream11XmlFriendlyMapper() {
        return false;
    }

    protected MapperWrapper wrapMapper(MapperWrapper mapperWrapper) {
        return mapperWrapper;
    }

    public XStream(ReflectionProvider reflectionProvider) {
        this(reflectionProvider, (Mapper) null, new XppDriver());
    }

    public void addImmutableType(Class cls, boolean z) {
        ImmutableTypesMapper immutableTypesMapper = this.immutableTypesMapper;
        if (immutableTypesMapper != null) {
            immutableTypesMapper.addImmutableType(cls, z);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls2 = class$com$thoughtworks$xstream$mapper$ImmutableTypesMapper;
        if (cls2 == null) {
            cls2 = class$("com.thoughtworks.xstream.mapper.ImmutableTypesMapper");
            class$com$thoughtworks$xstream$mapper$ImmutableTypesMapper = cls2;
        }
        stringBuffer.append(cls2.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void addImplicitArray(Class cls, String str, Class cls2) {
        addImplicitCollection(cls, str, cls2);
    }

    public void addImplicitCollection(Class cls, String str, Class cls2) {
        addImplicitCollection(cls, str, null, cls2);
    }

    public void addImplicitMap(Class cls, String str, String str2, Class cls2, String str3) {
        ImplicitCollectionMapper implicitCollectionMapper = this.implicitCollectionMapper;
        if (implicitCollectionMapper != null) {
            implicitCollectionMapper.add(cls, str, str2, cls2, str3);
            return;
        }
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("No ");
        Class cls3 = class$com$thoughtworks$xstream$mapper$ImplicitCollectionMapper;
        if (cls3 == null) {
            cls3 = class$("com.thoughtworks.xstream.mapper.ImplicitCollectionMapper");
            class$com$thoughtworks$xstream$mapper$ImplicitCollectionMapper = cls3;
        }
        stringBuffer.append(cls3.getName());
        stringBuffer.append(" available");
        throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
    }

    public void allowTypes(Class[] clsArr) {
        addPermission(new ExplicitTypePermission(clsArr));
    }

    public void allowTypesByRegExp(Pattern[] patternArr) {
        addPermission(new RegExpTypePermission(patternArr));
    }

    public ObjectInputStream createObjectInputStream(InputStream inputStream) throws IOException {
        return createObjectInputStream(this.hierarchicalStreamDriver.createReader(inputStream));
    }

    public void denyTypes(Class[] clsArr) {
        denyPermission(new ExplicitTypePermission(clsArr));
    }

    public void denyTypesByRegExp(Pattern[] patternArr) {
        denyPermission(new RegExpTypePermission(patternArr));
    }

    public Object fromXML(Reader reader) {
        return unmarshal(this.hierarchicalStreamDriver.createReader(reader), null);
    }

    public void ignoreUnknownElements(String str) {
        ignoreUnknownElements(Pattern.compile(str));
    }

    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, DataHolder dataHolder) {
        this.marshallingStrategy.marshal(hierarchicalStreamWriter, obj, this.converterLookup, this.mapper, dataHolder);
    }

    public void registerConverter(Converter converter, int i) {
        ConverterRegistry converterRegistry = this.converterRegistry;
        if (converterRegistry != null) {
            converterRegistry.registerConverter(converter, i);
        }
    }

    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, Object obj) {
        return unmarshal(hierarchicalStreamReader, obj, null);
    }

    public XStream(HierarchicalStreamDriver hierarchicalStreamDriver) {
        this((ReflectionProvider) null, (Mapper) null, hierarchicalStreamDriver);
    }

    public void addImplicitArray(Class cls, String str, String str2) {
        addImplicitCollection(cls, str, str2, null);
    }

    public void addImplicitCollection(Class cls, String str, String str2, Class cls2) {
        addImplicitMap(cls, str, str2, cls2, null);
    }

    public ObjectInputStream createObjectInputStream(HierarchicalStreamReader hierarchicalStreamReader) throws IOException {
        return createObjectInputStream(hierarchicalStreamReader, null);
    }

    public Object fromXML(InputStream inputStream) {
        return unmarshal(this.hierarchicalStreamDriver.createReader(inputStream), null);
    }

    public void ignoreUnknownElements(Pattern pattern) {
        ElementIgnoringMapper elementIgnoringMapper = this.elementIgnoringMapper;
        if (elementIgnoringMapper == null) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("No ");
            Class cls = class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper;
            if (cls == null) {
                cls = class$("com.thoughtworks.xstream.mapper.ElementIgnoringMapper");
                class$com$thoughtworks$xstream$mapper$ElementIgnoringMapper = cls;
            }
            stringBuffer.append(cls.getName());
            stringBuffer.append(" available");
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
        }
        elementIgnoringMapper.addElementsToIgnore(pattern);
    }

    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, Object obj, DataHolder dataHolder) {
        try {
            if (!this.securityInitialized && !this.securityWarningGiven) {
                this.securityWarningGiven = true;
                System.err.println("Security framework of XStream not initialized, XStream is probably vulnerable.");
            }
            return this.marshallingStrategy.unmarshal(obj, hierarchicalStreamReader, dataHolder, this.converterLookup, this.mapper);
        } catch (ConversionException e) {
            Package r8 = XStream.class.getPackage();
            String implementationVersion = r8 != null ? r8.getImplementationVersion() : null;
            if (implementationVersion == null) {
                implementationVersion = "not available";
            }
            e.add(MediationMetaData.KEY_VERSION, implementationVersion);
            throw e;
        }
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver) {
        this(reflectionProvider, (Mapper) null, hierarchicalStreamDriver);
    }

    public ObjectInputStream createObjectInputStream(final HierarchicalStreamReader hierarchicalStreamReader, final DataHolder dataHolder) throws IOException {
        return new CustomObjectInputStream(new CustomObjectInputStream.StreamCallback() { // from class: com.thoughtworks.xstream.XStream.4
            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void close() {
                hierarchicalStreamReader.close();
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void defaultReadObject() throws NotActiveException {
                throw new NotActiveException("not in call to readObject");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public Map readFieldsFromStream() throws IOException {
                throw new NotActiveException("not in call to readObject");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public Object readFromStream() throws EOFException {
                if (!hierarchicalStreamReader.hasMoreChildren()) {
                    throw new EOFException();
                }
                hierarchicalStreamReader.moveDown();
                Object unmarshal = XStream.this.unmarshal(hierarchicalStreamReader, dataHolder);
                hierarchicalStreamReader.moveUp();
                return unmarshal;
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void registerValidation(ObjectInputValidation objectInputValidation, int i) throws NotActiveException {
                throw new NotActiveException("stream inactive");
            }
        }, this.classLoaderReference);
    }

    public ObjectOutputStream createObjectOutputStream(HierarchicalStreamWriter hierarchicalStreamWriter) throws IOException {
        return createObjectOutputStream(hierarchicalStreamWriter, "object-stream");
    }

    public Object fromXML(URL url) {
        return fromXML(url, (Object) null);
    }

    public void processAnnotations(Class cls) {
        processAnnotations(new Class[]{cls});
    }

    public void registerConverter(SingleValueConverter singleValueConverter) {
        registerConverter(singleValueConverter, 0);
    }

    public void toXML(Object obj, Writer writer) {
        HierarchicalStreamWriter createWriter = this.hierarchicalStreamDriver.createWriter(writer);
        try {
            marshal(obj, createWriter);
        } finally {
            createWriter.flush();
        }
    }

    public XStream(ReflectionProvider reflectionProvider, Mapper mapper, HierarchicalStreamDriver hierarchicalStreamDriver) {
        this(reflectionProvider, hierarchicalStreamDriver, new CompositeClassLoader(), mapper);
    }

    public void alias(String str, Class cls, Class cls2) {
        alias(str, cls);
        addDefaultImplementation(cls2, cls);
    }

    public void aliasAttribute(Class cls, String str, String str2) {
        aliasField(str2, cls, str);
        useAttributeFor(cls, str);
    }

    public ObjectOutputStream createObjectOutputStream(Writer writer, String str) throws IOException {
        return createObjectOutputStream(this.hierarchicalStreamDriver.createWriter(writer), str);
    }

    public Object fromXML(File file) {
        return fromXML(file, (Object) null);
    }

    public void registerConverter(SingleValueConverter singleValueConverter, int i) {
        ConverterRegistry converterRegistry = this.converterRegistry;
        if (converterRegistry != null) {
            converterRegistry.registerConverter(new SingleValueConverterWrapper(singleValueConverter), i);
        }
    }

    public void registerLocalConverter(Class cls, String str, SingleValueConverter singleValueConverter) {
        registerLocalConverter(cls, str, (Converter) new SingleValueConverterWrapper(singleValueConverter));
    }

    public void useAttributeFor(Class cls, String str) {
        AttributeMapper attributeMapper = this.attributeMapper;
        if (attributeMapper == null) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("No ");
            Class cls2 = class$com$thoughtworks$xstream$mapper$AttributeMapper;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.mapper.AttributeMapper");
                class$com$thoughtworks$xstream$mapper$AttributeMapper = cls2;
            }
            stringBuffer.append(cls2.getName());
            stringBuffer.append(" available");
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
        }
        attributeMapper.addAttributeFor(cls, str);
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoaderReference classLoaderReference) {
        this(reflectionProvider, hierarchicalStreamDriver, classLoaderReference, (Mapper) null);
    }

    public Object fromXML(String str, Object obj) {
        return fromXML(new StringReader(str), obj);
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoader classLoader) {
        this(reflectionProvider, hierarchicalStreamDriver, classLoader, (Mapper) null);
    }

    public Object fromXML(Reader reader, Object obj) {
        return unmarshal(this.hierarchicalStreamDriver.createReader(reader), obj);
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoader classLoader, Mapper mapper) {
        this(reflectionProvider, hierarchicalStreamDriver, new ClassLoaderReference(classLoader), mapper, new DefaultConverterLookup());
    }

    public ObjectOutputStream createObjectOutputStream(OutputStream outputStream) throws IOException {
        return createObjectOutputStream(this.hierarchicalStreamDriver.createWriter(outputStream), "object-stream");
    }

    public Object fromXML(URL url, Object obj) {
        return unmarshal(this.hierarchicalStreamDriver.createReader(url), obj);
    }

    public void toXML(Object obj, OutputStream outputStream) {
        HierarchicalStreamWriter createWriter = this.hierarchicalStreamDriver.createWriter(outputStream);
        try {
            marshal(obj, createWriter);
        } finally {
            createWriter.flush();
        }
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoaderReference classLoaderReference, Mapper mapper) {
        this(reflectionProvider, hierarchicalStreamDriver, classLoaderReference, mapper, new DefaultConverterLookup());
    }

    public Object fromXML(File file, Object obj) {
        HierarchicalStreamReader createReader = this.hierarchicalStreamDriver.createReader(file);
        try {
            return unmarshal(createReader, obj);
        } finally {
            createReader.close();
        }
    }

    public void useAttributeFor(Class cls) {
        AttributeMapper attributeMapper = this.attributeMapper;
        if (attributeMapper == null) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("No ");
            Class cls2 = class$com$thoughtworks$xstream$mapper$AttributeMapper;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.mapper.AttributeMapper");
                class$com$thoughtworks$xstream$mapper$AttributeMapper = cls2;
            }
            stringBuffer.append(cls2.getName());
            stringBuffer.append(" available");
            throw new com.thoughtworks.xstream.InitializationException(stringBuffer.toString());
        }
        attributeMapper.addAttributeFor(cls);
    }

    private XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoaderReference classLoaderReference, Mapper mapper, final DefaultConverterLookup defaultConverterLookup) {
        this(reflectionProvider, hierarchicalStreamDriver, classLoaderReference, mapper, new ConverterLookup() { // from class: com.thoughtworks.xstream.XStream.1
            @Override // com.thoughtworks.xstream.converters.ConverterLookup
            public Converter lookupConverterForType(Class cls) {
                return DefaultConverterLookup.this.lookupConverterForType(cls);
            }
        }, new ConverterRegistry() { // from class: com.thoughtworks.xstream.XStream.2
            @Override // com.thoughtworks.xstream.converters.ConverterRegistry
            public void registerConverter(Converter converter, int i) {
                DefaultConverterLookup.this.registerConverter(converter, i);
            }
        });
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoader classLoader, Mapper mapper, ConverterLookup converterLookup, ConverterRegistry converterRegistry) {
        this(reflectionProvider, hierarchicalStreamDriver, new ClassLoaderReference(classLoader), mapper, converterLookup, converterRegistry);
    }

    public ObjectOutputStream createObjectOutputStream(OutputStream outputStream, String str) throws IOException {
        return createObjectOutputStream(this.hierarchicalStreamDriver.createWriter(outputStream), str);
    }

    public XStream(ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoaderReference classLoaderReference, Mapper mapper, ConverterLookup converterLookup, ConverterRegistry converterRegistry) {
        this.reflectionProvider = reflectionProvider == null ? JVM.newReflectionProvider() : reflectionProvider;
        this.hierarchicalStreamDriver = hierarchicalStreamDriver;
        this.classLoaderReference = classLoaderReference;
        this.converterLookup = converterLookup;
        this.converterRegistry = converterRegistry;
        this.mapper = mapper == null ? buildMapper() : mapper;
        setupMappers();
        setupSecurity();
        setupAliases();
        setupDefaultImplementations();
        setupConverters();
        setupImmutableTypes();
        setMode(1003);
    }

    public Object fromXML(InputStream inputStream, Object obj) {
        return unmarshal(this.hierarchicalStreamDriver.createReader(inputStream), obj);
    }

    public ObjectOutputStream createObjectOutputStream(HierarchicalStreamWriter hierarchicalStreamWriter, String str) throws IOException {
        return createObjectOutputStream(hierarchicalStreamWriter, str, null);
    }

    public ObjectOutputStream createObjectOutputStream(HierarchicalStreamWriter hierarchicalStreamWriter, String str, final DataHolder dataHolder) throws IOException {
        final StatefulWriter statefulWriter = new StatefulWriter(hierarchicalStreamWriter);
        statefulWriter.startNode(str, null);
        return new CustomObjectOutputStream(new CustomObjectOutputStream.StreamCallback() { // from class: com.thoughtworks.xstream.XStream.3
            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void close() {
                if (statefulWriter.state() != StatefulWriter.STATE_CLOSED) {
                    statefulWriter.endNode();
                    statefulWriter.close();
                }
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void defaultWriteObject() throws NotActiveException {
                throw new NotActiveException("not in call to writeObject");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void flush() {
                statefulWriter.flush();
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void writeFieldsToStream(Map map) throws NotActiveException {
                throw new NotActiveException("not in call to writeObject");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void writeToStream(Object obj) {
                XStream.this.marshal(obj, statefulWriter, dataHolder);
            }
        });
    }
}