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.thoughtworks.xstream.mapper.DefaultMapper;
import com.thoughtworks.xstream.mapper.Mapper;
import com.unity3d.ads.metadata.MediationMetaData;
import java.lang.reflect.Field;

/* loaded from: classes.dex */
public class JavaFieldConverter implements Converter {
    static /* synthetic */ Class class$java$lang$reflect$Field;
    private final SingleValueConverter javaClassConverter;
    private final Mapper mapper;

    public JavaFieldConverter(ClassLoaderReference classLoaderReference) {
        this(new JavaClassConverter(classLoaderReference), new DefaultMapper(classLoaderReference));
    }

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

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

    @Override // com.thoughtworks.xstream.converters.Converter
    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        Field field = (Field) obj;
        Class<?> declaringClass = field.getDeclaringClass();
        hierarchicalStreamWriter.startNode(MediationMetaData.KEY_NAME);
        hierarchicalStreamWriter.setValue(this.mapper.serializedMember(declaringClass, field.getName()));
        hierarchicalStreamWriter.endNode();
        hierarchicalStreamWriter.startNode("clazz");
        hierarchicalStreamWriter.setValue(this.javaClassConverter.toString(declaringClass));
        hierarchicalStreamWriter.endNode();
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        String str = null;
        String str2 = null;
        while (true) {
            if ((str == null || str2 == null) && hierarchicalStreamReader.hasMoreChildren()) {
                hierarchicalStreamReader.moveDown();
                if (hierarchicalStreamReader.getNodeName().equals(MediationMetaData.KEY_NAME)) {
                    str = hierarchicalStreamReader.getValue();
                } else if (hierarchicalStreamReader.getNodeName().equals("clazz")) {
                    str2 = hierarchicalStreamReader.getValue();
                }
                hierarchicalStreamReader.moveUp();
            }
        }
        Class cls = (Class) this.javaClassConverter.fromString(str2);
        try {
            return cls.getDeclaredField(this.mapper.realMember(cls, str));
        } catch (NoSuchFieldException e) {
            throw new ConversionException(e);
        }
    }

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

    protected JavaFieldConverter(SingleValueConverter singleValueConverter, Mapper mapper) {
        this.javaClassConverter = singleValueConverter;
        this.mapper = mapper;
    }
}