Initial commit
This commit is contained in:
@@ -0,0 +1,564 @@
|
||||
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");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user