Initial commit

sources/com/google/common/primitives/Longs.java

@@ -0,0 +1,209 @@
+package com.google.common.primitives;
+
+import com.google.common.base.Preconditions;
+import com.ubtrobot.jimu.robotapi.PeripheralType;
+import java.io.Serializable;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public final class Longs {
+
+    private static class LongArrayAsList extends AbstractList<Long> implements RandomAccess, Serializable {
+        final long[] a;
+        final int b;
+        final int c;
+
+        LongArrayAsList(long[] jArr, int i, int i2) {
+            this.a = jArr;
+            this.b = i;
+            this.c = i2;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public Long set(int i, Long l) {
+            Preconditions.a(i, size());
+            long[] jArr = this.a;
+            int i2 = this.b;
+            long j = jArr[i2 + i];
+            Preconditions.a(l);
+            jArr[i2 + i] = l.longValue();
+            return Long.valueOf(j);
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public boolean contains(Object obj) {
+            return (obj instanceof Long) && Longs.c(this.a, ((Long) obj).longValue(), this.b, this.c) != -1;
+        }
+
+        @Override // java.util.AbstractList, java.util.Collection, java.util.List
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof LongArrayAsList)) {
+                return super.equals(obj);
+            }
+            LongArrayAsList longArrayAsList = (LongArrayAsList) obj;
+            int size = size();
+            if (longArrayAsList.size() != size) {
+                return false;
+            }
+            for (int i = 0; i < size; i++) {
+                if (this.a[this.b + i] != longArrayAsList.a[longArrayAsList.b + i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override // java.util.AbstractList, java.util.Collection, java.util.List
+        public int hashCode() {
+            int i = 1;
+            for (int i2 = this.b; i2 < this.c; i2++) {
+                i = (i * 31) + Longs.a(this.a[i2]);
+            }
+            return i;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public int indexOf(Object obj) {
+            int c;
+            if (!(obj instanceof Long) || (c = Longs.c(this.a, ((Long) obj).longValue(), this.b, this.c)) < 0) {
+                return -1;
+            }
+            return c - this.b;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public int lastIndexOf(Object obj) {
+            int d;
+            if (!(obj instanceof Long) || (d = Longs.d(this.a, ((Long) obj).longValue(), this.b, this.c)) < 0) {
+                return -1;
+            }
+            return d - this.b;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public int size() {
+            return this.c - this.b;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public List<Long> subList(int i, int i2) {
+            Preconditions.b(i, i2, size());
+            if (i == i2) {
+                return Collections.emptyList();
+            }
+            long[] jArr = this.a;
+            int i3 = this.b;
+            return new LongArrayAsList(jArr, i + i3, i3 + i2);
+        }
+
+        @Override // java.util.AbstractCollection
+        public String toString() {
+            StringBuilder sb = new StringBuilder(size() * 10);
+            sb.append('[');
+            sb.append(this.a[this.b]);
+            int i = this.b;
+            while (true) {
+                i++;
+                if (i >= this.c) {
+                    sb.append(']');
+                    return sb.toString();
+                }
+                sb.append(", ");
+                sb.append(this.a[i]);
+            }
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public Long get(int i) {
+            Preconditions.a(i, size());
+            return Long.valueOf(this.a[this.b + i]);
+        }
+
+        long[] a() {
+            return Arrays.copyOfRange(this.a, this.b, this.c);
+        }
+    }
+
+    static {
+        a();
+    }
+
+    public static int a(long j) {
+        return (int) (j ^ (j >>> 32));
+    }
+
+    public static int a(long j, long j2) {
+        if (j < j2) {
+            return -1;
+        }
+        return j > j2 ? 1 : 0;
+    }
+
+    public static long a(byte b, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8) {
+        return ((b2 & 255) << 48) | ((b & 255) << 56) | ((b3 & 255) << 40) | ((b4 & 255) << 32) | ((b5 & 255) << 24) | ((b6 & 255) << 16) | ((b7 & 255) << 8) | (b8 & 255);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static int c(long[] jArr, long j, int i, int i2) {
+        while (i < i2) {
+            if (jArr[i] == j) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static int d(long[] jArr, long j, int i, int i2) {
+        for (int i3 = i2 - 1; i3 >= i; i3--) {
+            if (jArr[i3] == j) {
+                return i3;
+            }
+        }
+        return -1;
+    }
+
+    private static byte[] a() {
+        byte[] bArr = new byte[PeripheralType.SERVO];
+        Arrays.fill(bArr, (byte) -1);
+        for (int i = 0; i <= 9; i++) {
+            bArr[i + 48] = (byte) i;
+        }
+        for (int i2 = 0; i2 <= 26; i2++) {
+            byte b = (byte) (i2 + 10);
+            bArr[i2 + 65] = b;
+            bArr[i2 + 97] = b;
+        }
+        return bArr;
+    }
+
+    public static long[] a(Collection<? extends Number> collection) {
+        if (collection instanceof LongArrayAsList) {
+            return ((LongArrayAsList) collection).a();
+        }
+        Object[] array = collection.toArray();
+        int length = array.length;
+        long[] jArr = new long[length];
+        for (int i = 0; i < length; i++) {
+            Object obj = array[i];
+            Preconditions.a(obj);
+            jArr[i] = ((Number) obj).longValue();
+        }
+        return jArr;
+    }
+}