jimu-decompiled/sources/com/thoughtworks/xstream/converters/extended/JavaMethodConverter.java

package com.thoughtworks.xstream.converters.extended;

import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.SingleValueConverter;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.core.ClassLoaderReference;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.unity3d.ads.metadata.MediationMetaData;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;

/* loaded from: classes.dex */
public class JavaMethodConverter implements Converter {
    static /* synthetic */ Class class$java$lang$reflect$Constructor;
    static /* synthetic */ Class class$java$lang$reflect$Method;
    private final SingleValueConverter javaClassConverter;

    public JavaMethodConverter(ClassLoaderReference classLoaderReference) {
        this(new JavaClassConverter(classLoaderReference));
    }

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

    private void marshalMethod(HierarchicalStreamWriter hierarchicalStreamWriter, String str, String str2, Class[] clsArr) {
        hierarchicalStreamWriter.startNode("class");
        hierarchicalStreamWriter.setValue(str);
        hierarchicalStreamWriter.endNode();
        if (str2 != null) {
            hierarchicalStreamWriter.startNode(MediationMetaData.KEY_NAME);
            hierarchicalStreamWriter.setValue(str2);
            hierarchicalStreamWriter.endNode();
        }
        hierarchicalStreamWriter.startNode("parameter-types");
        for (Class cls : clsArr) {
            hierarchicalStreamWriter.startNode("class");
            hierarchicalStreamWriter.setValue(this.javaClassConverter.toString(cls));
            hierarchicalStreamWriter.endNode();
        }
        hierarchicalStreamWriter.endNode();
    }

    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
    public boolean canConvert(Class cls) {
        Class cls2 = class$java$lang$reflect$Method;
        if (cls2 == null) {
            cls2 = class$("java.lang.reflect.Method");
            class$java$lang$reflect$Method = cls2;
        }
        if (cls != cls2) {
            Class cls3 = class$java$lang$reflect$Constructor;
            if (cls3 == null) {
                cls3 = class$("java.lang.reflect.Constructor");
                class$java$lang$reflect$Constructor = cls3;
            }
            if (cls != cls3) {
                return false;
            }
        }
        return true;
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        if (obj instanceof Method) {
            Method method = (Method) obj;
            marshalMethod(hierarchicalStreamWriter, this.javaClassConverter.toString(method.getDeclaringClass()), method.getName(), method.getParameterTypes());
        } else {
            Constructor constructor = (Constructor) obj;
            marshalMethod(hierarchicalStreamWriter, this.javaClassConverter.toString(constructor.getDeclaringClass()), null, constructor.getParameterTypes());
        }
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        Class cls;
        try {
            Class requiredType = unmarshallingContext.getRequiredType();
            if (class$java$lang$reflect$Method == null) {
                cls = class$("java.lang.reflect.Method");
                class$java$lang$reflect$Method = cls;
            } else {
                cls = class$java$lang$reflect$Method;
            }
            boolean equals = requiredType.equals(cls);
            hierarchicalStreamReader.moveDown();
            Class cls2 = (Class) this.javaClassConverter.fromString(hierarchicalStreamReader.getValue());
            hierarchicalStreamReader.moveUp();
            String str = null;
            if (equals) {
                hierarchicalStreamReader.moveDown();
                str = hierarchicalStreamReader.getValue();
                hierarchicalStreamReader.moveUp();
            }
            hierarchicalStreamReader.moveDown();
            ArrayList arrayList = new ArrayList();
            while (hierarchicalStreamReader.hasMoreChildren()) {
                hierarchicalStreamReader.moveDown();
                arrayList.add(this.javaClassConverter.fromString(hierarchicalStreamReader.getValue()));
                hierarchicalStreamReader.moveUp();
            }
            Class<?>[] clsArr = (Class[]) arrayList.toArray(new Class[arrayList.size()]);
            hierarchicalStreamReader.moveUp();
            return equals ? cls2.getDeclaredMethod(str, clsArr) : cls2.getDeclaredConstructor(clsArr);
        } catch (NoSuchMethodException e) {
            throw new ConversionException(e);
        }
    }

    public JavaMethodConverter(ClassLoader classLoader) {
        this(new ClassLoaderReference(classLoader));
    }

    protected JavaMethodConverter(SingleValueConverter singleValueConverter) {
        this.javaClassConverter = singleValueConverter;
    }
}