596 lines
27 KiB
Java
596 lines
27 KiB
Java
package com.thoughtworks.xstream.mapper;
|
|
|
|
import com.thoughtworks.xstream.InitializationException;
|
|
import com.thoughtworks.xstream.annotations.XStreamAlias;
|
|
import com.thoughtworks.xstream.annotations.XStreamAliasType;
|
|
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
|
|
import com.thoughtworks.xstream.annotations.XStreamConverter;
|
|
import com.thoughtworks.xstream.annotations.XStreamConverters;
|
|
import com.thoughtworks.xstream.annotations.XStreamImplicitCollection;
|
|
import com.thoughtworks.xstream.annotations.XStreamInclude;
|
|
import com.thoughtworks.xstream.annotations.XStreamOmitField;
|
|
import com.thoughtworks.xstream.converters.Converter;
|
|
import com.thoughtworks.xstream.converters.ConverterLookup;
|
|
import com.thoughtworks.xstream.converters.ConverterMatcher;
|
|
import com.thoughtworks.xstream.converters.ConverterRegistry;
|
|
import com.thoughtworks.xstream.converters.SingleValueConverter;
|
|
import com.thoughtworks.xstream.converters.SingleValueConverterWrapper;
|
|
import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
|
|
import com.thoughtworks.xstream.core.ClassLoaderReference;
|
|
import com.thoughtworks.xstream.core.JVM;
|
|
import com.thoughtworks.xstream.core.util.DependencyInjectionFactory;
|
|
import com.thoughtworks.xstream.core.util.TypedNull;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.GenericArrayType;
|
|
import java.lang.reflect.ParameterizedType;
|
|
import java.lang.reflect.Type;
|
|
import java.lang.reflect.TypeVariable;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class AnnotationMapper extends MapperWrapper implements AnnotationConfiguration {
|
|
private final Set<Class<?>> annotatedTypes;
|
|
private transient Object[] arguments;
|
|
private transient AttributeMapper attributeMapper;
|
|
private transient ClassAliasingMapper classAliasingMapper;
|
|
private final Map<Class<?>, Map<List<Object>, Converter>> converterCache;
|
|
private final ConverterRegistry converterRegistry;
|
|
private transient DefaultImplementationsMapper defaultImplementationsMapper;
|
|
private transient ElementIgnoringMapper elementIgnoringMapper;
|
|
private transient FieldAliasingMapper fieldAliasingMapper;
|
|
private transient ImplicitCollectionMapper implicitCollectionMapper;
|
|
private transient LocalConversionMapper localConversionMapper;
|
|
private boolean locked;
|
|
|
|
private final class UnprocessedTypesSet extends LinkedHashSet<Class<?>> {
|
|
private UnprocessedTypesSet() {
|
|
}
|
|
|
|
@Override // java.util.HashSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean add(Class<?> cls) {
|
|
XStreamInclude xStreamInclude;
|
|
Class<?>[] value;
|
|
if (cls == null) {
|
|
return false;
|
|
}
|
|
while (cls.isArray()) {
|
|
cls = cls.getComponentType();
|
|
}
|
|
String name = cls.getName();
|
|
if (name.startsWith("java.") || name.startsWith("javax.")) {
|
|
return false;
|
|
}
|
|
boolean add = AnnotationMapper.this.annotatedTypes.contains(cls) ? false : super.add((UnprocessedTypesSet) cls);
|
|
if (add && (xStreamInclude = (XStreamInclude) cls.getAnnotation(XStreamInclude.class)) != null && (value = xStreamInclude.value()) != null) {
|
|
for (Class<?> cls2 : value) {
|
|
add(cls2);
|
|
}
|
|
}
|
|
return add;
|
|
}
|
|
}
|
|
|
|
public AnnotationMapper(Mapper mapper, ConverterRegistry converterRegistry, ConverterLookup converterLookup, ClassLoaderReference classLoaderReference, ReflectionProvider reflectionProvider) {
|
|
super(mapper);
|
|
this.converterCache = new HashMap();
|
|
this.annotatedTypes = Collections.synchronizedSet(new HashSet());
|
|
this.converterRegistry = converterRegistry;
|
|
this.annotatedTypes.add(Object.class);
|
|
setupMappers();
|
|
this.locked = true;
|
|
Object reference = classLoaderReference.getReference();
|
|
Object[] objArr = new Object[6];
|
|
objArr[0] = this;
|
|
objArr[1] = classLoaderReference;
|
|
objArr[2] = reflectionProvider;
|
|
objArr[3] = converterLookup;
|
|
objArr[4] = new JVM();
|
|
objArr[5] = reference == null ? new TypedNull(ClassLoader.class) : reference;
|
|
this.arguments = objArr;
|
|
}
|
|
|
|
private void addParametrizedTypes(Type type, final Set<Class<?>> set) {
|
|
final HashSet hashSet = new HashSet();
|
|
LinkedHashSet<Type> linkedHashSet = new LinkedHashSet<Type>() { // from class: com.thoughtworks.xstream.mapper.AnnotationMapper.1
|
|
@Override // java.util.HashSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean add(Type type2) {
|
|
if (type2 instanceof Class) {
|
|
return set.add((Class) type2);
|
|
}
|
|
if (type2 == null || hashSet.contains(type2)) {
|
|
return false;
|
|
}
|
|
return super.add((AnonymousClass1) type2);
|
|
}
|
|
};
|
|
while (type != null) {
|
|
hashSet.add(type);
|
|
int i = 0;
|
|
if (type instanceof Class) {
|
|
Class<?> cls = (Class) type;
|
|
set.add(cls);
|
|
if (!cls.isPrimitive()) {
|
|
for (TypeVariable<Class<?>> typeVariable : cls.getTypeParameters()) {
|
|
linkedHashSet.add(typeVariable);
|
|
}
|
|
linkedHashSet.add(cls.getGenericSuperclass());
|
|
Type[] genericInterfaces = cls.getGenericInterfaces();
|
|
int length = genericInterfaces.length;
|
|
while (i < length) {
|
|
linkedHashSet.add(genericInterfaces[i]);
|
|
i++;
|
|
}
|
|
}
|
|
} else if (type instanceof TypeVariable) {
|
|
Type[] bounds = ((TypeVariable) type).getBounds();
|
|
int length2 = bounds.length;
|
|
while (i < length2) {
|
|
linkedHashSet.add(bounds[i]);
|
|
i++;
|
|
}
|
|
} else if (type instanceof ParameterizedType) {
|
|
ParameterizedType parameterizedType = (ParameterizedType) type;
|
|
linkedHashSet.add(parameterizedType.getRawType());
|
|
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
|
int length3 = actualTypeArguments.length;
|
|
while (i < length3) {
|
|
linkedHashSet.add(actualTypeArguments[i]);
|
|
i++;
|
|
}
|
|
} else if (type instanceof GenericArrayType) {
|
|
linkedHashSet.add(((GenericArrayType) type).getGenericComponentType());
|
|
}
|
|
if (linkedHashSet.isEmpty()) {
|
|
type = null;
|
|
} else {
|
|
Iterator<Type> it = linkedHashSet.iterator();
|
|
Type next = it.next();
|
|
it.remove();
|
|
type = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
private Converter cacheConverter(XStreamConverter xStreamConverter, Class cls) {
|
|
Object[] objArr;
|
|
ArrayList arrayList = new ArrayList();
|
|
if (cls != null && xStreamConverter.useImplicitType()) {
|
|
arrayList.add(cls);
|
|
}
|
|
ArrayList arrayList2 = new ArrayList();
|
|
arrayList2.add(xStreamConverter.booleans());
|
|
arrayList2.add(xStreamConverter.bytes());
|
|
arrayList2.add(xStreamConverter.chars());
|
|
arrayList2.add(xStreamConverter.doubles());
|
|
arrayList2.add(xStreamConverter.floats());
|
|
arrayList2.add(xStreamConverter.ints());
|
|
arrayList2.add(xStreamConverter.longs());
|
|
arrayList2.add(xStreamConverter.shorts());
|
|
arrayList2.add(xStreamConverter.strings());
|
|
arrayList2.add(xStreamConverter.types());
|
|
Iterator it = arrayList2.iterator();
|
|
while (true) {
|
|
if (!it.hasNext()) {
|
|
break;
|
|
}
|
|
Object next = it.next();
|
|
if (next != null) {
|
|
int length = Array.getLength(next);
|
|
for (int i = 0; i < length; i++) {
|
|
arrayList.add(Array.get(next, i));
|
|
}
|
|
}
|
|
}
|
|
for (Class<?> cls2 : xStreamConverter.nulls()) {
|
|
arrayList.add(new TypedNull(cls2));
|
|
}
|
|
Class<? extends ConverterMatcher> value = xStreamConverter.value();
|
|
Map<List<Object>, Converter> map = this.converterCache.get(value);
|
|
Converter converter = map != null ? map.get(arrayList) : null;
|
|
if (converter == null) {
|
|
int size = arrayList.size();
|
|
if (size > 0) {
|
|
Object[] objArr2 = this.arguments;
|
|
objArr = new Object[objArr2.length + size];
|
|
System.arraycopy(objArr2, 0, objArr, size, objArr2.length);
|
|
System.arraycopy(arrayList.toArray(new Object[size]), 0, objArr, 0, size);
|
|
} else {
|
|
objArr = this.arguments;
|
|
}
|
|
try {
|
|
converter = (!SingleValueConverter.class.isAssignableFrom(value) || Converter.class.isAssignableFrom(value)) ? (Converter) DependencyInjectionFactory.newInstance(value, objArr) : new SingleValueConverterWrapper((SingleValueConverter) DependencyInjectionFactory.newInstance(value, objArr));
|
|
if (map == null) {
|
|
map = new HashMap<>();
|
|
this.converterCache.put(value, map);
|
|
}
|
|
map.put(arrayList, converter);
|
|
} catch (Exception e) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("Cannot instantiate converter ");
|
|
sb.append(value.getName());
|
|
sb.append(cls != null ? " for type " + cls.getName() : "");
|
|
throw new InitializationException(sb.toString(), e);
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
|
|
private Class<?> getClass(Type type) {
|
|
if (type instanceof ParameterizedType) {
|
|
return (Class) ((ParameterizedType) type).getRawType();
|
|
}
|
|
if (type instanceof Class) {
|
|
return (Class) type;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void processAliasAnnotation(Class<?> cls, Set<Class<?>> set) {
|
|
XStreamAlias xStreamAlias = (XStreamAlias) cls.getAnnotation(XStreamAlias.class);
|
|
if (xStreamAlias != null) {
|
|
ClassAliasingMapper classAliasingMapper = this.classAliasingMapper;
|
|
if (classAliasingMapper == null) {
|
|
throw new InitializationException("No " + ClassAliasingMapper.class.getName() + " available");
|
|
}
|
|
classAliasingMapper.addClassAlias(xStreamAlias.value(), cls);
|
|
if (xStreamAlias.impl() != Void.class) {
|
|
this.defaultImplementationsMapper.addDefaultImplementation(xStreamAlias.impl(), cls);
|
|
if (cls.isInterface()) {
|
|
set.add(xStreamAlias.impl());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void processAliasTypeAnnotation(Class<?> cls) {
|
|
XStreamAliasType xStreamAliasType = (XStreamAliasType) cls.getAnnotation(XStreamAliasType.class);
|
|
if (xStreamAliasType != null) {
|
|
ClassAliasingMapper classAliasingMapper = this.classAliasingMapper;
|
|
if (classAliasingMapper != null) {
|
|
classAliasingMapper.addTypeAlias(xStreamAliasType.value(), cls);
|
|
return;
|
|
}
|
|
throw new InitializationException("No " + ClassAliasingMapper.class.getName() + " available");
|
|
}
|
|
}
|
|
|
|
private void processAsAttributeAnnotation(Field field) {
|
|
if (((XStreamAsAttribute) field.getAnnotation(XStreamAsAttribute.class)) != null) {
|
|
AttributeMapper attributeMapper = this.attributeMapper;
|
|
if (attributeMapper != null) {
|
|
attributeMapper.addAttributeFor(field);
|
|
return;
|
|
}
|
|
throw new InitializationException("No " + AttributeMapper.class.getName() + " available");
|
|
}
|
|
}
|
|
|
|
private void processConverterAnnotations(Class<?> cls) {
|
|
if (this.converterRegistry != null) {
|
|
XStreamConverters xStreamConverters = (XStreamConverters) cls.getAnnotation(XStreamConverters.class);
|
|
XStreamConverter xStreamConverter = (XStreamConverter) cls.getAnnotation(XStreamConverter.class);
|
|
ArrayList<XStreamConverter> arrayList = xStreamConverters != null ? new ArrayList(Arrays.asList(xStreamConverters.value())) : new ArrayList();
|
|
if (xStreamConverter != null) {
|
|
arrayList.add(xStreamConverter);
|
|
}
|
|
for (XStreamConverter xStreamConverter2 : arrayList) {
|
|
Converter cacheConverter = cacheConverter(xStreamConverter2, xStreamConverter != null ? cls : null);
|
|
if (cacheConverter != null) {
|
|
if (xStreamConverter == null && !cacheConverter.canConvert(cls)) {
|
|
throw new InitializationException("Converter " + xStreamConverter2.value().getName() + " cannot handle annotated class " + cls.getName());
|
|
}
|
|
this.converterRegistry.registerConverter(cacheConverter, xStreamConverter2.priority());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void processFieldAliasAnnotation(Field field) {
|
|
XStreamAlias xStreamAlias = (XStreamAlias) field.getAnnotation(XStreamAlias.class);
|
|
if (xStreamAlias != null) {
|
|
FieldAliasingMapper fieldAliasingMapper = this.fieldAliasingMapper;
|
|
if (fieldAliasingMapper != null) {
|
|
fieldAliasingMapper.addFieldAlias(xStreamAlias.value(), field.getDeclaringClass(), field.getName());
|
|
return;
|
|
}
|
|
throw new InitializationException("No " + FieldAliasingMapper.class.getName() + " available");
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:12:0x004a */
|
|
/* JADX WARN: Removed duplicated region for block: B:25:0x006b */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct code enable 'Show inconsistent code' option in preferences
|
|
*/
|
|
private void processImplicitAnnotation(java.lang.reflect.Field r9) {
|
|
/*
|
|
r8 = this;
|
|
java.lang.Class<com.thoughtworks.xstream.annotations.XStreamImplicit> r0 = com.thoughtworks.xstream.annotations.XStreamImplicit.class
|
|
java.lang.annotation.Annotation r0 = r9.getAnnotation(r0)
|
|
com.thoughtworks.xstream.annotations.XStreamImplicit r0 = (com.thoughtworks.xstream.annotations.XStreamImplicit) r0
|
|
if (r0 == 0) goto La9
|
|
com.thoughtworks.xstream.mapper.ImplicitCollectionMapper r1 = r8.implicitCollectionMapper
|
|
if (r1 == 0) goto L87
|
|
java.lang.String r4 = r9.getName()
|
|
java.lang.String r1 = r0.itemFieldName()
|
|
java.lang.String r0 = r0.keyFieldName()
|
|
java.lang.Class<java.util.Map> r2 = java.util.Map.class
|
|
java.lang.Class r3 = r9.getType()
|
|
boolean r2 = r2.isAssignableFrom(r3)
|
|
java.lang.Class r3 = r9.getType()
|
|
boolean r3 = r3.isArray()
|
|
r5 = 0
|
|
if (r3 != 0) goto L45
|
|
java.lang.reflect.Type r3 = r9.getGenericType()
|
|
boolean r6 = r3 instanceof java.lang.reflect.ParameterizedType
|
|
if (r6 == 0) goto L45
|
|
java.lang.reflect.ParameterizedType r3 = (java.lang.reflect.ParameterizedType) r3
|
|
java.lang.reflect.Type[] r3 = r3.getActualTypeArguments()
|
|
r3 = r3[r2]
|
|
java.lang.Class r3 = r8.getClass(r3)
|
|
r6 = r3
|
|
goto L46
|
|
L45:
|
|
r6 = r5
|
|
L46:
|
|
java.lang.String r3 = ""
|
|
if (r2 == 0) goto L6b
|
|
com.thoughtworks.xstream.mapper.ImplicitCollectionMapper r2 = r8.implicitCollectionMapper
|
|
java.lang.Class r9 = r9.getDeclaringClass()
|
|
if (r1 == 0) goto L59
|
|
boolean r7 = r3.equals(r1)
|
|
if (r7 != 0) goto L59
|
|
goto L5a
|
|
L59:
|
|
r1 = r5
|
|
L5a:
|
|
if (r0 == 0) goto L64
|
|
boolean r3 = r3.equals(r0)
|
|
if (r3 != 0) goto L64
|
|
r7 = r0
|
|
goto L65
|
|
L64:
|
|
r7 = r5
|
|
L65:
|
|
r3 = r9
|
|
r5 = r1
|
|
r2.add(r3, r4, r5, r6, r7)
|
|
goto La9
|
|
L6b:
|
|
if (r1 == 0) goto L7d
|
|
boolean r0 = r3.equals(r1)
|
|
if (r0 != 0) goto L7d
|
|
com.thoughtworks.xstream.mapper.ImplicitCollectionMapper r0 = r8.implicitCollectionMapper
|
|
java.lang.Class r9 = r9.getDeclaringClass()
|
|
r0.add(r9, r4, r1, r6)
|
|
goto La9
|
|
L7d:
|
|
com.thoughtworks.xstream.mapper.ImplicitCollectionMapper r0 = r8.implicitCollectionMapper
|
|
java.lang.Class r9 = r9.getDeclaringClass()
|
|
r0.add(r9, r4, r6)
|
|
goto La9
|
|
L87:
|
|
com.thoughtworks.xstream.InitializationException r9 = new com.thoughtworks.xstream.InitializationException
|
|
java.lang.StringBuilder r0 = new java.lang.StringBuilder
|
|
r0.<init>()
|
|
java.lang.String r1 = "No "
|
|
r0.append(r1)
|
|
java.lang.Class<com.thoughtworks.xstream.mapper.ImplicitCollectionMapper> r1 = com.thoughtworks.xstream.mapper.ImplicitCollectionMapper.class
|
|
java.lang.String r1 = r1.getName()
|
|
r0.append(r1)
|
|
java.lang.String r1 = " available"
|
|
r0.append(r1)
|
|
java.lang.String r0 = r0.toString()
|
|
r9.<init>(r0)
|
|
throw r9
|
|
La9:
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.mapper.AnnotationMapper.processImplicitAnnotation(java.lang.reflect.Field):void");
|
|
}
|
|
|
|
@Deprecated
|
|
private void processImplicitCollectionAnnotation(Class<?> cls) {
|
|
XStreamImplicitCollection xStreamImplicitCollection = (XStreamImplicitCollection) cls.getAnnotation(XStreamImplicitCollection.class);
|
|
if (xStreamImplicitCollection != null) {
|
|
if (this.implicitCollectionMapper == null) {
|
|
throw new InitializationException("No " + ImplicitCollectionMapper.class.getName() + " available");
|
|
}
|
|
String value = xStreamImplicitCollection.value();
|
|
String item = xStreamImplicitCollection.item();
|
|
try {
|
|
Type genericType = cls.getDeclaredField(value).getGenericType();
|
|
Class<?> cls2 = genericType instanceof ParameterizedType ? getClass(((ParameterizedType) genericType).getActualTypeArguments()[0]) : null;
|
|
if (cls2 == null) {
|
|
this.implicitCollectionMapper.add(cls, value, null, Object.class);
|
|
} else if (item.equals("")) {
|
|
this.implicitCollectionMapper.add(cls, value, null, cls2);
|
|
} else {
|
|
this.implicitCollectionMapper.add(cls, value, item, cls2);
|
|
}
|
|
} catch (NoSuchFieldException unused) {
|
|
throw new InitializationException(cls.getName() + " does not have a field named '" + value + "' as required by " + XStreamImplicitCollection.class.getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void processLocalConverterAnnotation(Field field) {
|
|
Converter cacheConverter;
|
|
XStreamConverter xStreamConverter = (XStreamConverter) field.getAnnotation(XStreamConverter.class);
|
|
if (xStreamConverter == null || (cacheConverter = cacheConverter(xStreamConverter, field.getType())) == null) {
|
|
return;
|
|
}
|
|
LocalConversionMapper localConversionMapper = this.localConversionMapper;
|
|
if (localConversionMapper != null) {
|
|
localConversionMapper.registerLocalConverter(field.getDeclaringClass(), field.getName(), cacheConverter);
|
|
return;
|
|
}
|
|
throw new InitializationException("No " + LocalConversionMapper.class.getName() + " available");
|
|
}
|
|
|
|
private void processOmitFieldAnnotation(Field field) {
|
|
if (((XStreamOmitField) field.getAnnotation(XStreamOmitField.class)) != null) {
|
|
ElementIgnoringMapper elementIgnoringMapper = this.elementIgnoringMapper;
|
|
if (elementIgnoringMapper != null) {
|
|
elementIgnoringMapper.omitField(field.getDeclaringClass(), field.getName());
|
|
return;
|
|
}
|
|
throw new InitializationException("No " + ElementIgnoringMapper.class.getName() + " available");
|
|
}
|
|
}
|
|
|
|
private void processTypes(Set<Class<?>> set) {
|
|
while (!set.isEmpty()) {
|
|
Iterator<Class<?>> it = set.iterator();
|
|
Class<?> next = it.next();
|
|
it.remove();
|
|
synchronized (next) {
|
|
if (!this.annotatedTypes.contains(next)) {
|
|
try {
|
|
if (!next.isPrimitive()) {
|
|
addParametrizedTypes(next, set);
|
|
processConverterAnnotations(next);
|
|
processAliasAnnotation(next, set);
|
|
processAliasTypeAnnotation(next);
|
|
if (next.isInterface()) {
|
|
this.annotatedTypes.add(next);
|
|
} else {
|
|
processImplicitCollectionAnnotation(next);
|
|
for (Field field : next.getDeclaredFields()) {
|
|
if (!field.isEnumConstant() && (field.getModifiers() & 136) <= 0) {
|
|
addParametrizedTypes(field.getGenericType(), set);
|
|
if (!field.isSynthetic()) {
|
|
processFieldAliasAnnotation(field);
|
|
processAsAttributeAnnotation(field);
|
|
processImplicitAnnotation(field);
|
|
processOmitFieldAnnotation(field);
|
|
processLocalConverterAnnotation(field);
|
|
}
|
|
}
|
|
}
|
|
this.annotatedTypes.add(next);
|
|
}
|
|
}
|
|
} finally {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
|
|
objectInputStream.defaultReadObject();
|
|
setupMappers();
|
|
int readInt = objectInputStream.readInt();
|
|
this.arguments = new Object[readInt + 2];
|
|
for (int i = 0; i < readInt; i++) {
|
|
this.arguments[i] = objectInputStream.readObject();
|
|
Object[] objArr = this.arguments;
|
|
if (objArr[i] instanceof ClassLoaderReference) {
|
|
objArr[readInt + 1] = ((ClassLoaderReference) objArr[i]).getReference();
|
|
}
|
|
}
|
|
this.arguments[readInt] = new JVM();
|
|
}
|
|
|
|
private void setupMappers() {
|
|
this.classAliasingMapper = (ClassAliasingMapper) lookupMapperOfType(ClassAliasingMapper.class);
|
|
this.defaultImplementationsMapper = (DefaultImplementationsMapper) lookupMapperOfType(DefaultImplementationsMapper.class);
|
|
this.implicitCollectionMapper = (ImplicitCollectionMapper) lookupMapperOfType(ImplicitCollectionMapper.class);
|
|
this.fieldAliasingMapper = (FieldAliasingMapper) lookupMapperOfType(FieldAliasingMapper.class);
|
|
this.elementIgnoringMapper = (ElementIgnoringMapper) lookupMapperOfType(ElementIgnoringMapper.class);
|
|
this.attributeMapper = (AttributeMapper) lookupMapperOfType(AttributeMapper.class);
|
|
this.localConversionMapper = (LocalConversionMapper) lookupMapperOfType(LocalConversionMapper.class);
|
|
}
|
|
|
|
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
|
|
objectOutputStream.defaultWriteObject();
|
|
int length = this.arguments.length - 2;
|
|
objectOutputStream.writeInt(length);
|
|
for (int i = 0; i < length; i++) {
|
|
objectOutputStream.writeObject(this.arguments[i]);
|
|
}
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.AnnotationConfiguration
|
|
public void autodetectAnnotations(boolean z) {
|
|
this.locked = !z;
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
|
|
public Class defaultImplementationOf(Class cls) {
|
|
if (!this.locked) {
|
|
processAnnotations(cls);
|
|
}
|
|
Class defaultImplementationOf = super.defaultImplementationOf(cls);
|
|
if (!this.locked) {
|
|
processAnnotations(defaultImplementationOf);
|
|
}
|
|
return defaultImplementationOf;
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
|
|
public Converter getLocalConverter(Class cls, String str) {
|
|
if (!this.locked) {
|
|
processAnnotations(cls);
|
|
}
|
|
return super.getLocalConverter(cls, str);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.AnnotationConfiguration
|
|
public void processAnnotations(Class[] clsArr) {
|
|
if (clsArr == null || clsArr.length == 0) {
|
|
return;
|
|
}
|
|
this.locked = true;
|
|
UnprocessedTypesSet unprocessedTypesSet = new UnprocessedTypesSet();
|
|
for (Class cls : clsArr) {
|
|
unprocessedTypesSet.add((UnprocessedTypesSet) cls);
|
|
}
|
|
processTypes(unprocessedTypesSet);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
|
|
public String realMember(Class cls, String str) {
|
|
if (!this.locked) {
|
|
processAnnotations(cls);
|
|
}
|
|
return super.realMember(cls, str);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
|
|
public String serializedClass(Class cls) {
|
|
if (!this.locked) {
|
|
processAnnotations(cls);
|
|
}
|
|
return super.serializedClass(cls);
|
|
}
|
|
|
|
private void processAnnotations(Class cls) {
|
|
if (cls == null) {
|
|
return;
|
|
}
|
|
UnprocessedTypesSet unprocessedTypesSet = new UnprocessedTypesSet();
|
|
unprocessedTypesSet.add((UnprocessedTypesSet) cls);
|
|
processTypes(unprocessedTypesSet);
|
|
}
|
|
|
|
public AnnotationMapper(Mapper mapper, ConverterRegistry converterRegistry, ConverterLookup converterLookup, ClassLoader classLoader, ReflectionProvider reflectionProvider, JVM jvm) {
|
|
this(mapper, converterRegistry, converterLookup, new ClassLoaderReference(classLoader), reflectionProvider);
|
|
}
|
|
}
|