jimu-decompiled/sources/com/thoughtworks/xstream/converters/collections/TreeMapConverter.java

package com.thoughtworks.xstream.converters.collections;

import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
import com.thoughtworks.xstream.core.JVM;
import com.thoughtworks.xstream.core.util.Fields;
import com.thoughtworks.xstream.core.util.HierarchicalStreams;
import com.thoughtworks.xstream.core.util.PresortedMap;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.mapper.Mapper;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.SortedMap;
import java.util.TreeMap;

/* loaded from: classes.dex */
public class TreeMapConverter extends MapConverter {
    private static final Comparator NULL_MARKER = new NullComparator();
    static /* synthetic */ Class class$java$util$Comparator;
    static /* synthetic */ Class class$java$util$TreeMap;
    private static final Field comparatorField;

    private static final class NullComparator extends Mapper.Null implements Comparator {
        private NullComparator() {
        }

        @Override // java.util.Comparator
        public int compare(Object obj, Object obj2) {
            return ((Comparable) obj).compareTo(obj2);
        }
    }

    static {
        Class cls = class$java$util$TreeMap;
        if (cls == null) {
            cls = class$("java.util.TreeMap");
            class$java$util$TreeMap = cls;
        }
        Class cls2 = class$java$util$Comparator;
        if (cls2 == null) {
            cls2 = class$("java.util.Comparator");
            class$java$util$Comparator = cls2;
        }
        comparatorField = Fields.locate(cls, cls2, false);
    }

    /* 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 TreeMapConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
        /*
            r1 = this;
            java.lang.Class r0 = com.thoughtworks.xstream.converters.collections.TreeMapConverter.class$java$util$TreeMap
            if (r0 != 0) goto Lc
            java.lang.String r0 = "java.util.TreeMap"
            java.lang.Class r0 = class$(r0)
            com.thoughtworks.xstream.converters.collections.TreeMapConverter.class$java$util$TreeMap = r0
        Lc:
            r1.<init>(r2, r0)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.collections.TreeMapConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
    }

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

    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        marshalComparator(((SortedMap) obj).comparator(), hierarchicalStreamWriter, marshallingContext);
        super.marshal(obj, hierarchicalStreamWriter, marshallingContext);
    }

    protected void marshalComparator(Comparator comparator, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        if (comparator != null) {
            hierarchicalStreamWriter.startNode("comparator");
            hierarchicalStreamWriter.addAttribute(mapper().aliasForSystemAttribute("class"), mapper().serializedClass(comparator.getClass()));
            marshallingContext.convertAnother(comparator);
            hierarchicalStreamWriter.endNode();
        }
    }

    protected void populateTreeMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, TreeMap treeMap, Comparator comparator) {
        boolean z = comparator == NULL_MARKER;
        Comparator comparator2 = null;
        if (z) {
            comparator = null;
        }
        if (comparator != null && JVM.hasOptimizedTreeMapPutAll()) {
            comparator2 = comparator;
        }
        PresortedMap presortedMap = new PresortedMap(comparator2);
        if (z) {
            putCurrentEntryIntoMap(hierarchicalStreamReader, unmarshallingContext, treeMap, presortedMap);
            hierarchicalStreamReader.moveUp();
        }
        populateMap(hierarchicalStreamReader, unmarshallingContext, treeMap, presortedMap);
        try {
            if (JVM.hasOptimizedTreeMapPutAll()) {
                if (comparator != null && comparatorField != null) {
                    comparatorField.set(treeMap, comparator);
                }
                treeMap.putAll(presortedMap);
                return;
            }
            if (comparatorField == null) {
                treeMap.putAll(presortedMap);
                return;
            }
            comparatorField.set(treeMap, presortedMap.comparator());
            treeMap.putAll(presortedMap);
            comparatorField.set(treeMap, comparator);
        } catch (IllegalAccessException e) {
            throw new ObjectAccessException("Cannot set comparator of TreeMap", e);
        }
    }

    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        TreeMap treeMap = comparatorField != null ? new TreeMap() : null;
        Comparator unmarshalComparator = unmarshalComparator(hierarchicalStreamReader, unmarshallingContext, treeMap);
        if (treeMap == null) {
            treeMap = (unmarshalComparator == null || unmarshalComparator == NULL_MARKER) ? new TreeMap() : new TreeMap(unmarshalComparator);
        }
        populateTreeMap(hierarchicalStreamReader, unmarshallingContext, treeMap, unmarshalComparator);
        return treeMap;
    }

    protected Comparator unmarshalComparator(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, TreeMap treeMap) {
        Comparator comparator = null;
        if (hierarchicalStreamReader.hasMoreChildren()) {
            hierarchicalStreamReader.moveDown();
            if (hierarchicalStreamReader.getNodeName().equals("comparator")) {
                comparator = (Comparator) unmarshallingContext.convertAnother(treeMap, HierarchicalStreams.readClassType(hierarchicalStreamReader, mapper()));
            } else if (!hierarchicalStreamReader.getNodeName().equals("no-comparator")) {
                return NULL_MARKER;
            }
            hierarchicalStreamReader.moveUp();
        }
        return comparator;
    }
}