package gnu.trove;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/* loaded from: classes2.dex */
public class THashMap<K, V> extends TObjectHash<K> implements Map<K, V> {
    protected transient V[] _values;

    final class Entry implements Map.Entry<K, V> {
        private final K a;
        private V b;
        private final int c;

        Entry(K k, V v, int i) {
            this.a = k;
            this.b = v;
            this.c = i;
        }

        @Override // java.util.Map.Entry
        public K getKey() {
            return this.a;
        }

        @Override // java.util.Map.Entry
        public V getValue() {
            return this.b;
        }

        @Override // java.util.Map.Entry
        public V setValue(V v) {
            V[] vArr = THashMap.this._values;
            int i = this.c;
            V v2 = vArr[i];
            V v3 = this.b;
            if (v2 != v3) {
                throw new ConcurrentModificationException();
            }
            vArr[i] = v;
            this.b = v;
            return v3;
        }
    }

    protected class EntryView extends THashMap<K, V>.MapBackedView<Map.Entry<K, V>> {

        private final class EntryIterator extends THashIterator<Map.Entry<K, V>> {
            EntryIterator(THashMap<K, V> tHashMap) {
                super(tHashMap);
            }

            @Override // gnu.trove.THashIterator
            public THashMap<K, V>.Entry a(int i) {
                THashMap tHashMap = THashMap.this;
                return new Entry(tHashMap._set[i], tHashMap._values[i], i);
            }
        }

        EntryView() {
            super();
        }

        @Override // gnu.trove.THashMap.MapBackedView
        /* renamed from: c, reason: merged with bridge method [inline-methods] */
        public boolean b(Map.Entry<K, V> entry) {
            int index = THashMap.this.index(b((Map.Entry) entry));
            if (index < 0) {
                return false;
            }
            Object d = d(entry);
            V[] vArr = THashMap.this._values;
            if (d != vArr[index] && (d == null || !d.equals(vArr[index]))) {
                return false;
            }
            THashMap.this.removeAt(index);
            return true;
        }

        protected V d(Map.Entry<K, V> entry) {
            return entry.getValue();
        }

        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
        public Iterator<Map.Entry<K, V>> iterator() {
            return new EntryIterator(THashMap.this);
        }

        @Override // gnu.trove.THashMap.MapBackedView
        public boolean a(Map.Entry<K, V> entry) {
            Object obj = THashMap.this.get(b((Map.Entry) entry));
            V value = entry.getValue();
            return value == obj || (obj != null && obj.equals(value));
        }

        protected K b(Map.Entry<K, V> entry) {
            return entry.getKey();
        }
    }

    private static final class EqProcedure<K, V> implements TObjectObjectProcedure<K, V> {
        private final Map<K, V> a;

        EqProcedure(Map<K, V> map) {
            this.a = map;
        }

        @Override // gnu.trove.TObjectObjectProcedure
        public final boolean a(K k, V v) {
            V v2 = this.a.get(k);
            return v2 == v || (v2 != null && v2.equals(v));
        }
    }

    private final class HashProcedure implements TObjectObjectProcedure<K, V> {
        private int a;

        HashProcedure() {
        }

        public int a() {
            return this.a;
        }

        @Override // gnu.trove.TObjectObjectProcedure
        public final boolean a(K k, V v) {
            this.a += THashMap.this._hashingStrategy.computeHashCode(k) ^ (v == null ? 0 : v.hashCode());
            return true;
        }
    }

    protected class KeyView extends THashMap<K, V>.MapBackedView<K> {
        KeyView() {
            super();
        }

        @Override // gnu.trove.THashMap.MapBackedView
        public boolean a(K k) {
            return THashMap.this.contains(k);
        }

        @Override // gnu.trove.THashMap.MapBackedView
        public boolean b(K k) {
            return THashMap.this.remove(k) != null;
        }

        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
        public Iterator<K> iterator() {
            return new TObjectHashIterator(THashMap.this);
        }
    }

    protected class ValueView extends THashMap<K, V>.MapBackedView<V> {
        protected ValueView() {
            super();
        }

        @Override // gnu.trove.THashMap.MapBackedView
        public boolean a(V v) {
            return THashMap.this.containsValue(v);
        }

        @Override // gnu.trove.THashMap.MapBackedView
        public boolean b(V v) {
            THashMap tHashMap = THashMap.this;
            V[] vArr = tHashMap._values;
            Object[] objArr = tHashMap._set;
            int length = vArr.length;
            boolean z = false;
            while (true) {
                int i = length - 1;
                if (length <= 0) {
                    return z;
                }
                if ((objArr[i] != null && objArr[i] != TObjectHash.REMOVED && v == vArr[i]) || (vArr[i] != null && vArr[i].equals(v))) {
                    THashMap.this.removeAt(i);
                    z = true;
                }
                length = i;
            }
        }

        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
        public Iterator<V> iterator() {
            return new THashIterator<V>(THashMap.this) { // from class: gnu.trove.THashMap.ValueView.1
                @Override // gnu.trove.THashIterator
                protected V a(int i) {
                    return THashMap.this._values[i];
                }
            };
        }
    }

    public THashMap() {
    }

    /* JADX WARN: Multi-variable type inference failed */
    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
        objectInputStream.defaultReadObject();
        int readInt = objectInputStream.readInt();
        setUp(readInt);
        while (true) {
            int i = readInt - 1;
            if (readInt <= 0) {
                return;
            }
            put(objectInputStream.readObject(), objectInputStream.readObject());
            readInt = i;
        }
    }

    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
        objectOutputStream.defaultWriteObject();
        objectOutputStream.writeInt(this._size);
        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
        if (!forEachEntry(serializationProcedure)) {
            throw serializationProcedure.b;
        }
    }

    @Override // gnu.trove.THash
    public void clear() {
        if (size() == 0) {
            return;
        }
        super.clear();
        Object[] objArr = this._set;
        V[] vArr = this._values;
        int length = objArr.length;
        while (true) {
            int i = length - 1;
            if (length <= 0) {
                return;
            }
            objArr[i] = null;
            vArr[i] = null;
            length = i;
        }
    }

    @Override // java.util.Map
    public boolean containsKey(Object obj) {
        return contains(obj);
    }

    @Override // java.util.Map
    public boolean containsValue(Object obj) {
        Object[] objArr = this._set;
        V[] vArr = this._values;
        if (obj != null) {
            int length = vArr.length;
            while (true) {
                int i = length - 1;
                if (length <= 0) {
                    return false;
                }
                if (objArr[i] == null || objArr[i] == TObjectHash.REMOVED || (obj != vArr[i] && !obj.equals(vArr[i]))) {
                    length = i;
                }
            }
            return true;
        }
        int length2 = vArr.length;
        while (true) {
            int i2 = length2 - 1;
            if (length2 <= 0) {
                return false;
            }
            if (objArr[i2] != null && objArr[i2] != TObjectHash.REMOVED && obj == vArr[i2]) {
                return true;
            }
            length2 = i2;
        }
    }

    @Override // java.util.Map
    public Set<Map.Entry<K, V>> entrySet() {
        return new EntryView();
    }

    @Override // java.util.Map
    public boolean equals(Object obj) {
        if (!(obj instanceof Map)) {
            return false;
        }
        Map map = (Map) obj;
        if (map.size() != size()) {
            return false;
        }
        return forEachEntry(new EqProcedure(map));
    }

    /* JADX WARN: Multi-variable type inference failed */
    public boolean forEachEntry(TObjectObjectProcedure<K, V> tObjectObjectProcedure) {
        Object[] objArr = this._set;
        V[] vArr = this._values;
        int length = objArr.length;
        while (true) {
            int i = length - 1;
            if (length <= 0) {
                return true;
            }
            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectObjectProcedure.a(objArr[i], vArr[i])) {
                return false;
            }
            length = i;
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public boolean forEachKey(TObjectProcedure<K> tObjectProcedure) {
        return forEach(tObjectProcedure);
    }

    public boolean forEachValue(TObjectProcedure<V> tObjectProcedure) {
        V[] vArr = this._values;
        Object[] objArr = this._set;
        int length = vArr.length;
        while (true) {
            int i = length - 1;
            if (length <= 0) {
                return true;
            }
            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectProcedure.execute(vArr[i])) {
                return false;
            }
            length = i;
        }
    }

    @Override // java.util.Map
    public V get(Object obj) {
        int index = index(obj);
        if (index < 0) {
            return null;
        }
        return this._values[index];
    }

    @Override // java.util.Map
    public int hashCode() {
        HashProcedure hashProcedure = new HashProcedure();
        forEachEntry(hashProcedure);
        return hashProcedure.a();
    }

    @Override // java.util.Map
    public Set<K> keySet() {
        return new KeyView();
    }

    @Override // java.util.Map
    public V put(K k, V v) {
        if (k == null) {
            throw new NullPointerException("null keys not supported");
        }
        V v2 = null;
        int insertionIndex = insertionIndex(k);
        boolean z = insertionIndex < 0;
        if (z) {
            insertionIndex = (-insertionIndex) - 1;
            v2 = this._values[insertionIndex];
        }
        Object[] objArr = this._set;
        Object obj = objArr[insertionIndex];
        objArr[insertionIndex] = k;
        this._values[insertionIndex] = v;
        if (!z) {
            postInsertHook(obj == null);
        }
        return v2;
    }

    @Override // java.util.Map
    public void putAll(Map<? extends K, ? extends V> map) {
        ensureCapacity(map.size());
        for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) {
            put(entry.getKey(), entry.getValue());
        }
    }

    @Override // gnu.trove.THash
    protected void rehash(int i) {
        Object[] objArr = this._set;
        int length = objArr.length;
        V[] vArr = this._values;
        this._set = new Object[i];
        this._values = (V[]) new Object[i];
        while (true) {
            int i2 = length - 1;
            if (length <= 0) {
                return;
            }
            if (objArr[i2] != null && objArr[i2] != TObjectHash.REMOVED) {
                Object obj = objArr[i2];
                int insertionIndex = insertionIndex(obj);
                if (insertionIndex < 0) {
                    throwObjectContractViolation(this._set[(-insertionIndex) - 1], obj);
                }
                this._set[insertionIndex] = obj;
                this._values[insertionIndex] = vArr[i2];
            }
            length = i2;
        }
    }

    @Override // java.util.Map
    public V remove(Object obj) {
        int index = index(obj);
        if (index < 0) {
            return null;
        }
        V v = this._values[index];
        removeAt(index);
        return v;
    }

    @Override // gnu.trove.TObjectHash, gnu.trove.THash
    protected void removeAt(int i) {
        this._values[i] = null;
        super.removeAt(i);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public boolean retainEntries(TObjectObjectProcedure<K, V> tObjectObjectProcedure) {
        Object[] objArr = this._set;
        V[] vArr = this._values;
        stopCompactingOnRemove();
        boolean z = false;
        try {
            int length = objArr.length;
            while (true) {
                int i = length - 1;
                if (length <= 0) {
                    return z;
                }
                if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectObjectProcedure.a(objArr[i], vArr[i])) {
                    removeAt(i);
                    z = true;
                }
                length = i;
            }
        } finally {
            startCompactingOnRemove(z);
        }
    }

    @Override // gnu.trove.TObjectHash, gnu.trove.THash
    protected int setUp(int i) {
        int up = super.setUp(i);
        this._values = i == -1 ? (V[]) THash.EMPTY_OBJECT_ARRAY : (V[]) new Object[up];
        return up;
    }

    public String toString() {
        final StringBuilder sb = new StringBuilder();
        forEachEntry(new TObjectObjectProcedure<K, V>(this) { // from class: gnu.trove.THashMap.1
            @Override // gnu.trove.TObjectObjectProcedure
            public boolean a(K k, V v) {
                if (sb.length() != 0) {
                    StringBuilder sb2 = sb;
                    sb2.append(',');
                    sb2.append(' ');
                }
                StringBuilder sb3 = sb;
                if (k == this) {
                    k = (K) "(this Map)";
                }
                sb3.append(k);
                sb.append('=');
                StringBuilder sb4 = sb;
                if (v == this) {
                    v = (V) "(this Map)";
                }
                sb4.append(v);
                return true;
            }
        });
        sb.append('}');
        sb.insert(0, '{');
        return sb.toString();
    }

    public void transformValues(TObjectFunction<V, V> tObjectFunction) {
        V[] vArr = this._values;
        Object[] objArr = this._set;
        int length = vArr.length;
        while (true) {
            int i = length - 1;
            if (length <= 0) {
                return;
            }
            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED) {
                vArr[i] = tObjectFunction.execute(vArr[i]);
            }
            length = i;
        }
    }

    @Override // java.util.Map
    public Collection<V> values() {
        return new ValueView();
    }

    public THashMap(TObjectHashingStrategy<K> tObjectHashingStrategy) {
        super(tObjectHashingStrategy);
    }

    public THashMap(int i) {
        super(i);
    }

    @Override // gnu.trove.TObjectHash, gnu.trove.THash
    public THashMap<K, V> clone() {
        THashMap<K, V> tHashMap = (THashMap) super.clone();
        tHashMap._values = (V[]) ((Object[]) this._values.clone());
        return tHashMap;
    }

    private abstract class MapBackedView<E> implements Set<E> {
        MapBackedView() {
        }

        public abstract boolean a(E e);

        @Override // java.util.Set, java.util.Collection
        public boolean add(E e) {
            throw new UnsupportedOperationException();
        }

        @Override // java.util.Set, java.util.Collection
        public boolean addAll(Collection<? extends E> collection) {
            throw new UnsupportedOperationException();
        }

        public abstract boolean b(E e);

        @Override // java.util.Set, java.util.Collection
        public void clear() {
            THashMap.this.clear();
        }

        /* JADX WARN: Multi-variable type inference failed */
        @Override // java.util.Set, java.util.Collection
        public boolean contains(Object obj) {
            return a(obj);
        }

        @Override // java.util.Set, java.util.Collection
        public boolean containsAll(Collection<?> collection) {
            Iterator<?> it = collection.iterator();
            while (it.hasNext()) {
                if (!contains(it.next())) {
                    return false;
                }
            }
            return true;
        }

        @Override // java.util.Set, java.util.Collection
        public boolean isEmpty() {
            return THashMap.this.isEmpty();
        }

        @Override // java.util.Set, java.util.Collection, java.lang.Iterable
        public abstract Iterator<E> iterator();

        /* JADX WARN: Multi-variable type inference failed */
        @Override // java.util.Set, java.util.Collection
        public boolean remove(Object obj) {
            return b(obj);
        }

        @Override // java.util.Set, java.util.Collection
        public boolean removeAll(Collection<?> collection) {
            Iterator<?> it = collection.iterator();
            boolean z = false;
            while (it.hasNext()) {
                if (remove(it.next())) {
                    z = true;
                }
            }
            return z;
        }

        @Override // java.util.Set, java.util.Collection
        public boolean retainAll(Collection<?> collection) {
            Iterator<E> it = iterator();
            boolean z = false;
            while (it.hasNext()) {
                if (!collection.contains(it.next())) {
                    it.remove();
                    z = true;
                }
            }
            return z;
        }

        @Override // java.util.Set, java.util.Collection
        public int size() {
            return THashMap.this.size();
        }

        @Override // java.util.Set, java.util.Collection
        public Object[] toArray() {
            Object[] objArr = new Object[size()];
            Iterator<E> it = iterator();
            int i = 0;
            while (it.hasNext()) {
                objArr[i] = it.next();
                i++;
            }
            return objArr;
        }

        @Override // java.util.Set, java.util.Collection
        public <T> T[] toArray(T[] tArr) {
            int size = size();
            if (tArr.length < size) {
                tArr = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), size));
            }
            Iterator<E> it = iterator();
            for (int i = 0; i < size; i++) {
                tArr[i] = it.next();
            }
            if (tArr.length > size) {
                tArr[size] = null;
            }
            return tArr;
        }
    }

    public THashMap(int i, TObjectHashingStrategy<K> tObjectHashingStrategy) {
        super(i, tObjectHashingStrategy);
    }

    public THashMap(int i, float f) {
        super(i, f);
    }

    public THashMap(int i, float f, TObjectHashingStrategy<K> tObjectHashingStrategy) {
        super(i, f, tObjectHashingStrategy);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public THashMap(Map<K, V> map) {
        this(map.size());
        putAll(map);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public THashMap(Map<K, V> map, TObjectHashingStrategy<K> tObjectHashingStrategy) {
        this(map.size(), tObjectHashingStrategy);
        putAll(map);
    }
}