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