jimu-decompiled/sources/com/thoughtworks/xstream/converters/javabean/JavaBeanConverter.java

package com.thoughtworks.xstream.converters.javabean;

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.converters.javabean.JavaBeanProvider;
import com.thoughtworks.xstream.converters.reflection.MissingFieldException;
import com.thoughtworks.xstream.core.util.FastField;
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.util.HashSet;

/* loaded from: classes.dex */
public class JavaBeanConverter implements Converter {
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
    protected final JavaBeanProvider beanProvider;
    private String classAttributeIdentifier;
    protected final Mapper mapper;
    private final Class type;

    public static class DuplicateFieldException extends ConversionException {
        public DuplicateFieldException(String str) {
            super(str);
        }
    }

    public static class DuplicatePropertyException 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 DuplicatePropertyException(java.lang.String r3) {
            /*
                r2 = this;
                java.lang.StringBuffer r0 = new java.lang.StringBuffer
                r0.<init>()
                java.lang.String r1 = "Duplicate property "
                r0.append(r1)
                r0.append(r3)
                java.lang.String r0 = r0.toString()
                r2.<init>(r0)
                java.lang.String r0 = "property"
                r2.add(r0, r3)
                return
            */
            throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.DuplicatePropertyException.<init>(java.lang.String):void");
        }
    }

    public JavaBeanConverter(Mapper mapper) {
        this(mapper, (Class) null);
    }

    static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError().initCause(e);
        }
    }

    private Class determineType(HierarchicalStreamReader hierarchicalStreamReader, Object obj, String str) {
        String str2 = this.classAttributeIdentifier;
        if (str2 == null) {
            str2 = this.mapper.aliasForSystemAttribute("class");
        }
        String attribute = str2 == null ? null : hierarchicalStreamReader.getAttribute(str2);
        return attribute != null ? this.mapper.realClass(attribute) : this.mapper.defaultImplementationOf(this.beanProvider.getPropertyType(obj, str));
    }

    private Object instantiateNewInstance(UnmarshallingContext unmarshallingContext) {
        Object currentObject = unmarshallingContext.currentObject();
        return currentObject == null ? this.beanProvider.newInstance(unmarshallingContext.getRequiredType()) : currentObject;
    }

    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
    public boolean canConvert(Class cls) {
        Class cls2 = this.type;
        return (cls2 == null || cls2 == cls) && this.beanProvider.canInstantiate(cls);
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public void marshal(final Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, final MarshallingContext marshallingContext) {
        final String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class");
        this.beanProvider.visitSerializableProperties(obj, new JavaBeanProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.1
            private void writeField(String str, Class cls, Object obj2) {
                String str2;
                Class<?> cls2 = obj2.getClass();
                Class defaultImplementationOf = JavaBeanConverter.this.mapper.defaultImplementationOf(cls);
                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, JavaBeanConverter.this.mapper.serializedMember(obj.getClass(), str), cls2);
                if (!cls2.equals(defaultImplementationOf) && (str2 = aliasForSystemAttribute) != null) {
                    hierarchicalStreamWriter.addAttribute(str2, JavaBeanConverter.this.mapper.serializedClass(cls2));
                }
                marshallingContext.convertAnother(obj2);
                hierarchicalStreamWriter.endNode();
            }

            private void writeNullField(String str) {
                String serializedMember = JavaBeanConverter.this.mapper.serializedMember(obj.getClass(), str);
                HierarchicalStreamWriter hierarchicalStreamWriter2 = hierarchicalStreamWriter;
                Class cls = JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null;
                if (cls == null) {
                    cls = JavaBeanConverter.class$("com.thoughtworks.xstream.mapper.Mapper$Null");
                    JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
                }
                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter2, serializedMember, cls);
                HierarchicalStreamWriter hierarchicalStreamWriter3 = hierarchicalStreamWriter;
                String str2 = aliasForSystemAttribute;
                Mapper mapper = JavaBeanConverter.this.mapper;
                Class cls2 = JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null;
                if (cls2 == null) {
                    cls2 = JavaBeanConverter.class$("com.thoughtworks.xstream.mapper.Mapper$Null");
                    JavaBeanConverter.class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
                }
                hierarchicalStreamWriter3.addAttribute(str2, mapper.serializedClass(cls2));
                hierarchicalStreamWriter.endNode();
            }

            @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider.Visitor
            public boolean shouldVisit(String str, Class cls) {
                return JavaBeanConverter.this.mapper.shouldSerializeMember(cls, str);
            }

            @Override // com.thoughtworks.xstream.converters.javabean.JavaBeanProvider.Visitor
            public void visit(String str, Class cls, Class cls2, Object obj2) {
                if (obj2 != null) {
                    writeField(str, cls, obj2);
                } else {
                    writeNullField(str);
                }
            }
        });
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        Object instantiateNewInstance = instantiateNewInstance(unmarshallingContext);
        HashSet hashSet = new HashSet() { // from class: com.thoughtworks.xstream.converters.javabean.JavaBeanConverter.2
            @Override // java.util.HashSet, java.util.AbstractCollection, java.util.Collection, java.util.Set
            public boolean add(Object obj) {
                if (super.add(obj)) {
                    return true;
                }
                throw new DuplicatePropertyException(((FastField) obj).getName());
            }
        };
        Class<?> cls = instantiateNewInstance.getClass();
        while (hierarchicalStreamReader.hasMoreChildren()) {
            hierarchicalStreamReader.moveDown();
            String realMember = this.mapper.realMember(cls, hierarchicalStreamReader.getNodeName());
            if (this.mapper.shouldSerializeMember(cls, realMember)) {
                if (this.beanProvider.propertyDefinedInClass(realMember, cls)) {
                    this.beanProvider.writeProperty(instantiateNewInstance, realMember, unmarshallingContext.convertAnother(instantiateNewInstance, determineType(hierarchicalStreamReader, instantiateNewInstance, realMember)));
                    hashSet.add(new FastField(cls, realMember));
                } else if (!this.mapper.isIgnoredElement(realMember)) {
                    throw new MissingFieldException(cls.getName(), realMember);
                }
            }
            hierarchicalStreamReader.moveUp();
        }
        return instantiateNewInstance;
    }

    public JavaBeanConverter(Mapper mapper, Class cls) {
        this(mapper, new BeanProvider(), cls);
    }

    public JavaBeanConverter(Mapper mapper, JavaBeanProvider javaBeanProvider) {
        this(mapper, javaBeanProvider, null);
    }

    public JavaBeanConverter(Mapper mapper, JavaBeanProvider javaBeanProvider, Class cls) {
        this.mapper = mapper;
        this.beanProvider = javaBeanProvider;
        this.type = cls;
    }

    public JavaBeanConverter(Mapper mapper, String str) {
        this(mapper, new BeanProvider());
        this.classAttributeIdentifier = str;
    }
}