2197 lines
104 KiB
Java
2197 lines
104 KiB
Java
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);
|
|
}
|
|
});
|
|
}
|
|
}
|