Initial commit

sources/com/thoughtworks/xstream/converters/reflection/AbstractReflectionConverter.java

@@ -0,0 +1,383 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.Caching;
+import com.thoughtworks.xstream.core.ReferencingMarshallingContext;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.core.util.SerializationMembers;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class AbstractReflectionConverter implements Converter, Caching {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    static /* synthetic */ Class class$java$lang$Object;
+    static /* synthetic */ Class class$java$util$Collection;
+    static /* synthetic */ Class class$java$util$Map;
+    static /* synthetic */ Class class$java$util$Map$Entry;
+    protected final Mapper mapper;
+    private transient ReflectionProvider pureJavaReflectionProvider;
+    protected final ReflectionProvider reflectionProvider;
+    protected transient SerializationMethodInvoker serializationMethodInvoker = new SerializationMethodInvoker();
+    protected transient SerializationMembers serializationMembers = this.serializationMethodInvoker.serializationMembers;
+
+    private static class ArraysList extends ArrayList {
+        final Class physicalFieldType;
+
+        ArraysList(Class cls) {
+            this.physicalFieldType = cls;
+        }
+
+        Object toPhysicalArray() {
+            Object[] array = toArray();
+            Object newInstance = Array.newInstance(this.physicalFieldType.getComponentType(), array.length);
+            if (this.physicalFieldType.getComponentType().isPrimitive()) {
+                for (int i = 0; i < array.length; i++) {
+                    Array.set(newInstance, i, Array.get(array, i));
+                }
+            } else {
+                System.arraycopy(array, 0, newInstance, 0, array.length);
+            }
+            return newInstance;
+        }
+    }
+
+    public static class DuplicateFieldException extends ConversionException {
+        /* 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 DuplicateFieldException(java.lang.String r3) {
+            /*
+                r2 = this;
+                java.lang.StringBuffer r0 = new java.lang.StringBuffer
+                r0.<init>()
+                java.lang.String r1 = "Duplicate field "
+                r0.append(r1)
+                r0.append(r3)
+                java.lang.String r0 = r0.toString()
+                r2.<init>(r0)
+                java.lang.String r0 = "field"
+                r2.add(r0, r3)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.DuplicateFieldException.<init>(java.lang.String):void");
+        }
+    }
+
+    private static class FieldInfo extends FieldLocation {
+        final Class type;
+        final Object value;
+
+        FieldInfo(String str, Class cls, Class cls2, Object obj) {
+            super(str, cls2);
+            this.type = cls;
+            this.value = obj;
+        }
+    }
+
+    private static class FieldLocation {
+        final Class definedIn;
+        final String fieldName;
+
+        FieldLocation(String str, Class cls) {
+            this.fieldName = str;
+            this.definedIn = cls;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || getClass() != obj.getClass()) {
+                return false;
+            }
+            FieldLocation fieldLocation = (FieldLocation) obj;
+            if (this.definedIn != fieldLocation.definedIn) {
+                return false;
+            }
+            String str = this.fieldName;
+            if (str == null) {
+                if (fieldLocation.fieldName != null) {
+                    return false;
+                }
+            } else if (!str.equals(fieldLocation.fieldName)) {
+                return false;
+            }
+            return true;
+        }
+
+        public int hashCode() {
+            Class cls = this.definedIn;
+            int hashCode = ((cls == null ? 0 : cls.getName().hashCode()) + 7) * 7;
+            String str = this.fieldName;
+            return hashCode + (str != null ? str.hashCode() : 0);
+        }
+    }
+
+    private interface FieldMarshaller {
+        void writeField(String str, String str2, Class cls, Class cls2, Object obj);
+
+        void writeItem(Object obj);
+    }
+
+    private class MappingList extends AbstractList {
+        private final Map fieldCache = new HashMap();
+        private final String keyFieldName;
+        private final Map map;
+
+        public MappingList(Map map, String str) {
+            this.map = map;
+            this.keyFieldName = str;
+        }
+
+        @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+        public boolean add(Object obj) {
+            if (obj == null) {
+                boolean z = !this.map.containsKey(null);
+                this.map.put(null, null);
+                return z;
+            }
+            Class<?> cls = obj.getClass();
+            if (this.keyFieldName != null) {
+                Field field = (Field) this.fieldCache.get(cls);
+                if (field == null) {
+                    field = AbstractReflectionConverter.this.reflectionProvider.getField(cls, this.keyFieldName);
+                    this.fieldCache.put(cls, field);
+                }
+                if (field != null) {
+                    return this.map.put(Fields.read(field, obj), obj) == null;
+                }
+            } else if (obj instanceof Map.Entry) {
+                Map.Entry entry = (Map.Entry) obj;
+                return this.map.put(entry.getKey(), entry.getValue()) == null;
+            }
+            ConversionException conversionException = new ConversionException("Element  is not defined as entry for implicit map");
+            conversionException.add("map-type", this.map.getClass().getName());
+            conversionException.add("element-type", obj.getClass().getName());
+            throw conversionException;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public Object get(int i) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public int size() {
+            return this.map.size();
+        }
+    }
+
+    public static class UnknownFieldException extends ConversionException {
+        /* 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 UnknownFieldException(java.lang.String r3, java.lang.String r4) {
+            /*
+                r2 = this;
+                java.lang.StringBuffer r0 = new java.lang.StringBuffer
+                r0.<init>()
+                java.lang.String r1 = "No such field "
+                r0.append(r1)
+                r0.append(r3)
+                java.lang.String r3 = "."
+                r0.append(r3)
+                r0.append(r4)
+                java.lang.String r3 = r0.toString()
+                r2.<init>(r3)
+                java.lang.String r3 = "field"
+                r2.add(r3, r4)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.UnknownFieldException.<init>(java.lang.String, java.lang.String):void");
+        }
+    }
+
+    public AbstractReflectionConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
+        this.mapper = mapper;
+        this.reflectionProvider = reflectionProvider;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private void handleUnknownField(Class cls, String str, Class cls2, String str2) {
+        if (cls == null) {
+            for (Class cls3 = cls2; cls3 != null; cls3 = cls3.getSuperclass()) {
+                if (!this.mapper.shouldSerializeMember(cls3, str2)) {
+                    return;
+                }
+            }
+        }
+        throw new UnknownFieldException(cls2.getName(), str);
+    }
+
+    private Class readDeclaringClass(HierarchicalStreamReader hierarchicalStreamReader) {
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("defined-in");
+        String attribute = aliasForSystemAttribute == null ? null : hierarchicalStreamReader.getAttribute(aliasForSystemAttribute);
+        if (attribute == null) {
+            return null;
+        }
+        return this.mapper.realClass(attribute);
+    }
+
+    private void writeValueToImplicitCollection(Object obj, Map map, Object obj2, FieldLocation fieldLocation) {
+        Collection collection = (Collection) map.get(fieldLocation);
+        if (collection == null) {
+            Field fieldOrNull = this.reflectionProvider.getFieldOrNull(fieldLocation.definedIn, fieldLocation.fieldName);
+            Class type = fieldOrNull != null ? fieldOrNull.getType() : this.reflectionProvider.getFieldType(obj2, fieldLocation.fieldName, null);
+            if (type.isArray()) {
+                collection = new ArraysList(type);
+            } else {
+                Class<?> defaultImplementationOf = this.mapper.defaultImplementationOf(type);
+                Class cls = class$java$util$Collection;
+                if (cls == null) {
+                    cls = class$("java.util.Collection");
+                    class$java$util$Collection = cls;
+                }
+                if (!cls.isAssignableFrom(defaultImplementationOf)) {
+                    Class cls2 = class$java$util$Map;
+                    if (cls2 == null) {
+                        cls2 = class$("java.util.Map");
+                        class$java$util$Map = cls2;
+                    }
+                    if (!cls2.isAssignableFrom(defaultImplementationOf)) {
+                        ObjectAccessException objectAccessException = new ObjectAccessException("Field is configured for an implicit Collection or Map, but is of an incompatible type");
+                        StringBuffer stringBuffer = new StringBuffer();
+                        stringBuffer.append(obj2.getClass().getName());
+                        stringBuffer.append(".");
+                        stringBuffer.append(fieldLocation.fieldName);
+                        objectAccessException.add("field", stringBuffer.toString());
+                        objectAccessException.add("field-type", defaultImplementationOf.getName());
+                        throw objectAccessException;
+                    }
+                }
+                if (this.pureJavaReflectionProvider == null) {
+                    this.pureJavaReflectionProvider = new PureJavaReflectionProvider();
+                }
+                Object newInstance = this.pureJavaReflectionProvider.newInstance(defaultImplementationOf);
+                Collection mappingList = newInstance instanceof Collection ? (Collection) newInstance : new MappingList((Map) newInstance, this.mapper.getImplicitCollectionDefForFieldName(fieldLocation.definedIn, fieldLocation.fieldName).getKeyFieldName());
+                this.reflectionProvider.writeField(obj2, fieldLocation.fieldName, newInstance, fieldOrNull != null ? fieldOrNull.getDeclaringClass() : null);
+                collection = mappingList;
+            }
+            map.put(fieldLocation, collection);
+        }
+        collection.add(obj);
+    }
+
+    protected boolean canAccess(Class cls) {
+        try {
+            this.reflectionProvider.getFieldOrNull(cls, "%");
+            return true;
+        } catch (NoClassDefFoundError unused) {
+            return false;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x017f A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x008d A[SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    protected void doMarshal(final java.lang.Object r20, final com.thoughtworks.xstream.io.HierarchicalStreamWriter r21, final com.thoughtworks.xstream.converters.MarshallingContext r22) {
+        /*
+            Method dump skipped, instructions count: 399
+            To view this dump change 'Code comments level' option to 'DEBUG'
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.doMarshal(java.lang.Object, com.thoughtworks.xstream.io.HierarchicalStreamWriter, com.thoughtworks.xstream.converters.MarshallingContext):void");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:51:0x0100  */
+    /* JADX WARN: Removed duplicated region for block: B:59:0x0218  */
+    /* JADX WARN: Removed duplicated region for block: B:62:0x022e  */
+    /* JADX WARN: Removed duplicated region for block: B:76:0x0103  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public java.lang.Object doUnmarshal(java.lang.Object r13, com.thoughtworks.xstream.io.HierarchicalStreamReader r14, com.thoughtworks.xstream.converters.UnmarshallingContext r15) {
+        /*
+            Method dump skipped, instructions count: 676
+            To view this dump change 'Code comments level' option to 'DEBUG'
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.doUnmarshal(java.lang.Object, com.thoughtworks.xstream.io.HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext):java.lang.Object");
+    }
+
+    @Override // com.thoughtworks.xstream.core.Caching
+    public void flushCache() {
+        this.serializationMethodInvoker.flushCache();
+    }
+
+    protected Object instantiateNewInstance(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("resolves-to");
+        String attribute = aliasForSystemAttribute == null ? null : hierarchicalStreamReader.getAttribute(aliasForSystemAttribute);
+        Object currentObject = unmarshallingContext.currentObject();
+        return currentObject != null ? currentObject : attribute != null ? this.reflectionProvider.newInstance(this.mapper.realClass(attribute)) : this.reflectionProvider.newInstance(unmarshallingContext.getRequiredType());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Object callWriteReplace = this.serializationMembers.callWriteReplace(obj);
+        if (callWriteReplace != obj && (marshallingContext instanceof ReferencingMarshallingContext)) {
+            ((ReferencingMarshallingContext) marshallingContext).replace(obj, callWriteReplace);
+        }
+        if (callWriteReplace.getClass() == obj.getClass()) {
+            doMarshal(callWriteReplace, hierarchicalStreamWriter, marshallingContext);
+            return;
+        }
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("resolves-to");
+        if (aliasForSystemAttribute != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(callWriteReplace.getClass()));
+        }
+        marshallingContext.convertAnother(callWriteReplace);
+    }
+
+    protected void marshallField(MarshallingContext marshallingContext, Object obj, Field field) {
+        marshallingContext.convertAnother(obj, this.mapper.getLocalConverter(field.getDeclaringClass(), field.getName()));
+    }
+
+    protected Object readResolve() {
+        this.serializationMethodInvoker = new SerializationMethodInvoker();
+        this.serializationMembers = this.serializationMethodInvoker.serializationMembers;
+        return this;
+    }
+
+    protected boolean shouldUnmarshalField(Field field) {
+        return !Modifier.isTransient(field.getModifiers()) || shouldUnmarshalTransientFields();
+    }
+
+    protected boolean shouldUnmarshalTransientFields() {
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return this.serializationMembers.callReadResolve(doUnmarshal(instantiateNewInstance(hierarchicalStreamReader, unmarshallingContext), hierarchicalStreamReader, unmarshallingContext));
+    }
+
+    protected Object unmarshallField(UnmarshallingContext unmarshallingContext, Object obj, Class cls, Field field) {
+        return unmarshallingContext.convertAnother(obj, cls, this.mapper.getLocalConverter(field.getDeclaringClass(), field.getName()));
+    }
+}