package com.thoughtworks.xstream.mapper;

import com.thoughtworks.xstream.InitializationException;
import java.util.HashMap;
import java.util.Map;

/* loaded from: classes.dex */
public class DefaultImplementationsMapper extends MapperWrapper {
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
    static /* synthetic */ Class class$java$lang$Boolean;
    static /* synthetic */ Class class$java$lang$Byte;
    static /* synthetic */ Class class$java$lang$Character;
    static /* synthetic */ Class class$java$lang$Double;
    static /* synthetic */ Class class$java$lang$Float;
    static /* synthetic */ Class class$java$lang$Integer;
    static /* synthetic */ Class class$java$lang$Long;
    static /* synthetic */ Class class$java$lang$Short;
    private transient Map implToType;
    private final Map typeToImpl;

    public DefaultImplementationsMapper(Mapper mapper) {
        super(mapper);
        this.typeToImpl = new HashMap();
        this.implToType = new HashMap();
        addDefaults();
    }

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

    private Object readResolve() {
        this.implToType = new HashMap();
        for (Object obj : this.typeToImpl.keySet()) {
            this.implToType.put(this.typeToImpl.get(obj), obj);
        }
        return this;
    }

    public void addDefaultImplementation(Class cls, Class cls2) {
        if (cls == null || !cls.isInterface()) {
            this.typeToImpl.put(cls2, cls);
            this.implToType.put(cls, cls2);
        } else {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("Default implementation is not a concrete class: ");
            stringBuffer.append(cls.getName());
            throw new InitializationException(stringBuffer.toString());
        }
    }

    protected void addDefaults() {
        Class cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
        if (cls == null) {
            cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
        }
        addDefaultImplementation(null, cls);
        Class cls2 = class$java$lang$Boolean;
        if (cls2 == null) {
            cls2 = class$("java.lang.Boolean");
            class$java$lang$Boolean = cls2;
        }
        addDefaultImplementation(cls2, Boolean.TYPE);
        Class cls3 = class$java$lang$Character;
        if (cls3 == null) {
            cls3 = class$("java.lang.Character");
            class$java$lang$Character = cls3;
        }
        addDefaultImplementation(cls3, Character.TYPE);
        Class cls4 = class$java$lang$Integer;
        if (cls4 == null) {
            cls4 = class$("java.lang.Integer");
            class$java$lang$Integer = cls4;
        }
        addDefaultImplementation(cls4, Integer.TYPE);
        Class cls5 = class$java$lang$Float;
        if (cls5 == null) {
            cls5 = class$("java.lang.Float");
            class$java$lang$Float = cls5;
        }
        addDefaultImplementation(cls5, Float.TYPE);
        Class cls6 = class$java$lang$Double;
        if (cls6 == null) {
            cls6 = class$("java.lang.Double");
            class$java$lang$Double = cls6;
        }
        addDefaultImplementation(cls6, Double.TYPE);
        Class cls7 = class$java$lang$Short;
        if (cls7 == null) {
            cls7 = class$("java.lang.Short");
            class$java$lang$Short = cls7;
        }
        addDefaultImplementation(cls7, Short.TYPE);
        Class cls8 = class$java$lang$Byte;
        if (cls8 == null) {
            cls8 = class$("java.lang.Byte");
            class$java$lang$Byte = cls8;
        }
        addDefaultImplementation(cls8, Byte.TYPE);
        Class cls9 = class$java$lang$Long;
        if (cls9 == null) {
            cls9 = class$("java.lang.Long");
            class$java$lang$Long = cls9;
        }
        addDefaultImplementation(cls9, Long.TYPE);
    }

    @Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
    public Class defaultImplementationOf(Class cls) {
        return this.typeToImpl.containsKey(cls) ? (Class) this.typeToImpl.get(cls) : super.defaultImplementationOf(cls);
    }

    @Override // com.thoughtworks.xstream.mapper.MapperWrapper, com.thoughtworks.xstream.mapper.Mapper
    public String serializedClass(Class cls) {
        Class cls2 = (Class) this.implToType.get(cls);
        return cls2 == null ? super.serializedClass(cls) : super.serializedClass(cls2);
    }
}