Initial commit

sources/gnu/trove/TByteHash.java

@@ -0,0 +1,150 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class TByteHash extends TPrimitiveHash implements TByteHashingStrategy {
+    protected final TByteHashingStrategy _hashingStrategy;
+    protected transient byte[] _set;
+
+    public TByteHash() {
+        this._hashingStrategy = this;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteHash tByteHash = (TByteHash) super.clone();
+        byte[] bArr = this._set;
+        tByteHash._set = bArr == null ? null : (byte[]) bArr.clone();
+        return tByteHash;
+    }
+
+    @Override // gnu.trove.TByteHashingStrategy
+    public final int computeHashCode(byte b) {
+        HashFunctions.a((int) b);
+        return b;
+    }
+
+    public boolean contains(byte b) {
+        return index(b) >= 0;
+    }
+
+    public boolean forEach(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    protected int index(byte b) {
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return -1;
+        }
+        byte[] bArr2 = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] != 0 && (bArr[i] == 2 || bArr2[i] != b)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (bArr[i] == 0 || (bArr[i] != 2 && bArr2[i] == b)) {
+                    break;
+                }
+            }
+        }
+        if (bArr[i] == 0) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(byte b) {
+        if (this._set == null) {
+            setUp(6);
+        }
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] == 0) {
+            return i;
+        }
+        if (bArr[i] == 1 && bArr2[i] == b) {
+            return (-i) - 1;
+        }
+        int i2 = (computeHashCode % (length - 2)) + 1;
+        do {
+            i -= i2;
+            if (i < 0) {
+                i += length;
+            }
+            if (bArr[i] != 1) {
+                break;
+            }
+        } while (bArr2[i] != b);
+        if (bArr[i] != 2) {
+            return bArr[i] == 1 ? (-i) - 1 : i;
+        }
+        int i3 = i;
+        while (bArr[i3] != 0 && (bArr[i3] == 2 || bArr2[i3] != b)) {
+            i3 -= i2;
+            if (i3 < 0) {
+                i3 += length;
+            }
+        }
+        return bArr[i3] == 1 ? (-i3) - 1 : i;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._set[i] = 0;
+        super.removeAt(i);
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._set = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public TByteHash(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TByteHash(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TByteHash(TByteHashingStrategy tByteHashingStrategy) {
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteHash(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteHash(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+}