Initial commit

sources/com/google/common/util/concurrent/AtomicDouble.java

@@ -0,0 +1,99 @@
+package com.google.common.util.concurrent;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+
+/* loaded from: classes.dex */
+public class AtomicDouble extends Number implements Serializable {
+    private static final long serialVersionUID = 0;
+    private static final AtomicLongFieldUpdater<AtomicDouble> updater = AtomicLongFieldUpdater.newUpdater(AtomicDouble.class, "value");
+    private volatile transient long value;
+
+    public AtomicDouble(double d) {
+        this.value = Double.doubleToRawLongBits(d);
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        set(objectInputStream.readDouble());
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeDouble(get());
+    }
+
+    public final double addAndGet(double d) {
+        long j;
+        double longBitsToDouble;
+        do {
+            j = this.value;
+            longBitsToDouble = Double.longBitsToDouble(j) + d;
+        } while (!updater.compareAndSet(this, j, Double.doubleToRawLongBits(longBitsToDouble)));
+        return longBitsToDouble;
+    }
+
+    public final boolean compareAndSet(double d, double d2) {
+        return updater.compareAndSet(this, Double.doubleToRawLongBits(d), Double.doubleToRawLongBits(d2));
+    }
+
+    @Override // java.lang.Number
+    public double doubleValue() {
+        return get();
+    }
+
+    @Override // java.lang.Number
+    public float floatValue() {
+        return (float) get();
+    }
+
+    public final double get() {
+        return Double.longBitsToDouble(this.value);
+    }
+
+    public final double getAndAdd(double d) {
+        long j;
+        double longBitsToDouble;
+        do {
+            j = this.value;
+            longBitsToDouble = Double.longBitsToDouble(j);
+        } while (!updater.compareAndSet(this, j, Double.doubleToRawLongBits(longBitsToDouble + d)));
+        return longBitsToDouble;
+    }
+
+    public final double getAndSet(double d) {
+        return Double.longBitsToDouble(updater.getAndSet(this, Double.doubleToRawLongBits(d)));
+    }
+
+    @Override // java.lang.Number
+    public int intValue() {
+        return (int) get();
+    }
+
+    public final void lazySet(double d) {
+        set(d);
+    }
+
+    @Override // java.lang.Number
+    public long longValue() {
+        return (long) get();
+    }
+
+    public final void set(double d) {
+        this.value = Double.doubleToRawLongBits(d);
+    }
+
+    public String toString() {
+        return Double.toString(get());
+    }
+
+    public final boolean weakCompareAndSet(double d, double d2) {
+        return updater.weakCompareAndSet(this, Double.doubleToRawLongBits(d), Double.doubleToRawLongBits(d2));
+    }
+
+    public AtomicDouble() {
+    }
+}

sources/com/google/common/util/concurrent/AtomicDoubleArray.java

@@ -0,0 +1,112 @@
+package com.google.common.util.concurrent;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.concurrent.atomic.AtomicLongArray;
+
+/* loaded from: classes.dex */
+public class AtomicDoubleArray implements Serializable {
+    private static final long serialVersionUID = 0;
+    private transient AtomicLongArray longs;
+
+    public AtomicDoubleArray(int i) {
+        this.longs = new AtomicLongArray(i);
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        this.longs = new AtomicLongArray(readInt);
+        for (int i = 0; i < readInt; i++) {
+            set(i, objectInputStream.readDouble());
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        int length = length();
+        objectOutputStream.writeInt(length);
+        for (int i = 0; i < length; i++) {
+            objectOutputStream.writeDouble(get(i));
+        }
+    }
+
+    public double addAndGet(int i, double d) {
+        long j;
+        double longBitsToDouble;
+        do {
+            j = this.longs.get(i);
+            longBitsToDouble = Double.longBitsToDouble(j) + d;
+        } while (!this.longs.compareAndSet(i, j, Double.doubleToRawLongBits(longBitsToDouble)));
+        return longBitsToDouble;
+    }
+
+    public final boolean compareAndSet(int i, double d, double d2) {
+        return this.longs.compareAndSet(i, Double.doubleToRawLongBits(d), Double.doubleToRawLongBits(d2));
+    }
+
+    public final double get(int i) {
+        return Double.longBitsToDouble(this.longs.get(i));
+    }
+
+    public final double getAndAdd(int i, double d) {
+        long j;
+        double longBitsToDouble;
+        do {
+            j = this.longs.get(i);
+            longBitsToDouble = Double.longBitsToDouble(j);
+        } while (!this.longs.compareAndSet(i, j, Double.doubleToRawLongBits(longBitsToDouble + d)));
+        return longBitsToDouble;
+    }
+
+    public final double getAndSet(int i, double d) {
+        return Double.longBitsToDouble(this.longs.getAndSet(i, Double.doubleToRawLongBits(d)));
+    }
+
+    public final void lazySet(int i, double d) {
+        set(i, d);
+    }
+
+    public final int length() {
+        return this.longs.length();
+    }
+
+    public final void set(int i, double d) {
+        this.longs.set(i, Double.doubleToRawLongBits(d));
+    }
+
+    public String toString() {
+        int length = length() - 1;
+        if (length == -1) {
+            return "[]";
+        }
+        StringBuilder sb = new StringBuilder((length + 1) * 19);
+        sb.append('[');
+        int i = 0;
+        while (true) {
+            sb.append(Double.longBitsToDouble(this.longs.get(i)));
+            if (i == length) {
+                sb.append(']');
+                return sb.toString();
+            }
+            sb.append(',');
+            sb.append(' ');
+            i++;
+        }
+    }
+
+    public final boolean weakCompareAndSet(int i, double d, double d2) {
+        return this.longs.weakCompareAndSet(i, Double.doubleToRawLongBits(d), Double.doubleToRawLongBits(d2));
+    }
+
+    public AtomicDoubleArray(double[] dArr) {
+        int length = dArr.length;
+        long[] jArr = new long[length];
+        for (int i = 0; i < length; i++) {
+            jArr[i] = Double.doubleToRawLongBits(dArr[i]);
+        }
+        this.longs = new AtomicLongArray(jArr);
+    }
+}

sources/com/google/common/util/concurrent/AtomicLongMap.java

@@ -0,0 +1,239 @@
+package com.google.common.util.concurrent;
+
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes.dex */
+public final class AtomicLongMap<K> implements Serializable {
+    private transient Map<K, Long> asMap;
+    private final ConcurrentHashMap<K, AtomicLong> map;
+
+    private AtomicLongMap(ConcurrentHashMap<K, AtomicLong> concurrentHashMap) {
+        Preconditions.a(concurrentHashMap);
+        this.map = concurrentHashMap;
+    }
+
+    public static <K> AtomicLongMap<K> create() {
+        return new AtomicLongMap<>(new ConcurrentHashMap());
+    }
+
+    private Map<K, Long> createAsMap() {
+        return Collections.unmodifiableMap(Maps.a((Map) this.map, (Function) new Function<AtomicLong, Long>(this) { // from class: com.google.common.util.concurrent.AtomicLongMap.1
+            @Override // com.google.common.base.Function
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public Long apply(AtomicLong atomicLong) {
+                return Long.valueOf(atomicLong.get());
+            }
+        }));
+    }
+
+    public long addAndGet(K k, long j) {
+        AtomicLong atomicLong;
+        long j2;
+        long j3;
+        do {
+            atomicLong = this.map.get(k);
+            if (atomicLong == null && (atomicLong = this.map.putIfAbsent(k, new AtomicLong(j))) == null) {
+                return j;
+            }
+            do {
+                j2 = atomicLong.get();
+                if (j2 != 0) {
+                    j3 = j2 + j;
+                }
+            } while (!atomicLong.compareAndSet(j2, j3));
+            return j3;
+        } while (!this.map.replace(k, atomicLong, new AtomicLong(j)));
+        return j;
+    }
+
+    public Map<K, Long> asMap() {
+        Map<K, Long> map = this.asMap;
+        if (map != null) {
+            return map;
+        }
+        Map<K, Long> createAsMap = createAsMap();
+        this.asMap = createAsMap;
+        return createAsMap;
+    }
+
+    public void clear() {
+        this.map.clear();
+    }
+
+    public boolean containsKey(Object obj) {
+        return this.map.containsKey(obj);
+    }
+
+    public long decrementAndGet(K k) {
+        return addAndGet(k, -1L);
+    }
+
+    public long get(K k) {
+        AtomicLong atomicLong = this.map.get(k);
+        if (atomicLong == null) {
+            return 0L;
+        }
+        return atomicLong.get();
+    }
+
+    public long getAndAdd(K k, long j) {
+        AtomicLong atomicLong;
+        long j2;
+        do {
+            atomicLong = this.map.get(k);
+            if (atomicLong == null && (atomicLong = this.map.putIfAbsent(k, new AtomicLong(j))) == null) {
+                return 0L;
+            }
+            do {
+                j2 = atomicLong.get();
+                if (j2 == 0) {
+                }
+            } while (!atomicLong.compareAndSet(j2, j2 + j));
+            return j2;
+        } while (!this.map.replace(k, atomicLong, new AtomicLong(j)));
+        return 0L;
+    }
+
+    public long getAndDecrement(K k) {
+        return getAndAdd(k, -1L);
+    }
+
+    public long getAndIncrement(K k) {
+        return getAndAdd(k, 1L);
+    }
+
+    public long incrementAndGet(K k) {
+        return addAndGet(k, 1L);
+    }
+
+    public boolean isEmpty() {
+        return this.map.isEmpty();
+    }
+
+    public long put(K k, long j) {
+        AtomicLong atomicLong;
+        long j2;
+        do {
+            atomicLong = this.map.get(k);
+            if (atomicLong == null && (atomicLong = this.map.putIfAbsent(k, new AtomicLong(j))) == null) {
+                return 0L;
+            }
+            do {
+                j2 = atomicLong.get();
+                if (j2 == 0) {
+                }
+            } while (!atomicLong.compareAndSet(j2, j));
+            return j2;
+        } while (!this.map.replace(k, atomicLong, new AtomicLong(j)));
+        return 0L;
+    }
+
+    public void putAll(Map<? extends K, ? extends Long> map) {
+        for (Map.Entry<? extends K, ? extends Long> entry : map.entrySet()) {
+            put(entry.getKey(), entry.getValue().longValue());
+        }
+    }
+
+    long putIfAbsent(K k, long j) {
+        AtomicLong atomicLong;
+        do {
+            atomicLong = this.map.get(k);
+            if (atomicLong == null && (atomicLong = this.map.putIfAbsent(k, new AtomicLong(j))) == null) {
+                return 0L;
+            }
+            long j2 = atomicLong.get();
+            if (j2 != 0) {
+                return j2;
+            }
+        } while (!this.map.replace(k, atomicLong, new AtomicLong(j)));
+        return 0L;
+    }
+
+    public long remove(K k) {
+        long j;
+        AtomicLong atomicLong = this.map.get(k);
+        if (atomicLong == null) {
+            return 0L;
+        }
+        do {
+            j = atomicLong.get();
+            if (j == 0) {
+                break;
+            }
+        } while (!atomicLong.compareAndSet(j, 0L));
+        this.map.remove(k, atomicLong);
+        return j;
+    }
+
+    public void removeAllZeros() {
+        Iterator<Map.Entry<K, AtomicLong>> it = this.map.entrySet().iterator();
+        while (it.hasNext()) {
+            AtomicLong value = it.next().getValue();
+            if (value != null && value.get() == 0) {
+                it.remove();
+            }
+        }
+    }
+
+    public boolean removeIfZero(K k) {
+        return remove(k, 0L);
+    }
+
+    boolean replace(K k, long j, long j2) {
+        if (j == 0) {
+            return putIfAbsent(k, j2) == 0;
+        }
+        AtomicLong atomicLong = this.map.get(k);
+        if (atomicLong == null) {
+            return false;
+        }
+        return atomicLong.compareAndSet(j, j2);
+    }
+
+    public int size() {
+        return this.map.size();
+    }
+
+    public long sum() {
+        Iterator<AtomicLong> it = this.map.values().iterator();
+        long j = 0;
+        while (it.hasNext()) {
+            j += it.next().get();
+        }
+        return j;
+    }
+
+    public String toString() {
+        return this.map.toString();
+    }
+
+    public static <K> AtomicLongMap<K> create(Map<? extends K, ? extends Long> map) {
+        AtomicLongMap<K> create = create();
+        create.putAll(map);
+        return create;
+    }
+
+    boolean remove(K k, long j) {
+        AtomicLong atomicLong = this.map.get(k);
+        if (atomicLong == null) {
+            return false;
+        }
+        long j2 = atomicLong.get();
+        if (j2 != j) {
+            return false;
+        }
+        if (j2 != 0 && !atomicLong.compareAndSet(j2, 0L)) {
+            return false;
+        }
+        this.map.remove(k, atomicLong);
+        return true;
+    }
+}

sources/com/google/common/util/concurrent/CycleDetectingLockFactory.java

@@ -0,0 +1,95 @@
+package com.google.common.util.concurrent;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapMaker;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.logging.Logger;
+
+/* loaded from: classes.dex */
+public class CycleDetectingLockFactory {
+
+    private static class ExampleStackTrace extends IllegalStateException {
+        static final StackTraceElement[] EMPTY_STACK_TRACE = new StackTraceElement[0];
+        static final ImmutableSet<String> EXCLUDED_CLASS_NAMES = ImmutableSet.of(CycleDetectingLockFactory.class.getName(), ExampleStackTrace.class.getName(), LockGraphNode.class.getName());
+
+        ExampleStackTrace(LockGraphNode lockGraphNode, LockGraphNode lockGraphNode2) {
+            super(lockGraphNode.a() + " -> " + lockGraphNode2.a());
+            StackTraceElement[] stackTrace = getStackTrace();
+            int length = stackTrace.length;
+            for (int i = 0; i < length; i++) {
+                if (WithExplicitOrdering.class.getName().equals(stackTrace[i].getClassName())) {
+                    setStackTrace(EMPTY_STACK_TRACE);
+                    return;
+                } else {
+                    if (!EXCLUDED_CLASS_NAMES.contains(stackTrace[i].getClassName())) {
+                        setStackTrace((StackTraceElement[]) Arrays.copyOfRange(stackTrace, i, length));
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    private static class LockGraphNode {
+        final String a;
+
+        String a() {
+            return this.a;
+        }
+    }
+
+    public enum Policies implements Policy {
+        THROW { // from class: com.google.common.util.concurrent.CycleDetectingLockFactory.Policies.1
+        },
+        WARN { // from class: com.google.common.util.concurrent.CycleDetectingLockFactory.Policies.2
+        },
+        DISABLED { // from class: com.google.common.util.concurrent.CycleDetectingLockFactory.Policies.3
+        }
+    }
+
+    public interface Policy {
+    }
+
+    public static final class PotentialDeadlockException extends ExampleStackTrace {
+        private final ExampleStackTrace conflictingStackTrace;
+
+        public ExampleStackTrace getConflictingStackTrace() {
+            return this.conflictingStackTrace;
+        }
+
+        @Override // java.lang.Throwable
+        public String getMessage() {
+            StringBuilder sb = new StringBuilder(super.getMessage());
+            for (Throwable th = this.conflictingStackTrace; th != null; th = th.getCause()) {
+                sb.append(", ");
+                sb.append(th.getMessage());
+            }
+            return sb.toString();
+        }
+
+        private PotentialDeadlockException(LockGraphNode lockGraphNode, LockGraphNode lockGraphNode2, ExampleStackTrace exampleStackTrace) {
+            super(lockGraphNode, lockGraphNode2);
+            this.conflictingStackTrace = exampleStackTrace;
+            initCause(exampleStackTrace);
+        }
+    }
+
+    public static final class WithExplicitOrdering<E extends Enum<E>> extends CycleDetectingLockFactory {
+    }
+
+    static {
+        MapMaker mapMaker = new MapMaker();
+        mapMaker.g();
+        mapMaker.f();
+        Logger.getLogger(CycleDetectingLockFactory.class.getName());
+        new ThreadLocal<ArrayList<LockGraphNode>>() { // from class: com.google.common.util.concurrent.CycleDetectingLockFactory.1
+            /* JADX INFO: Access modifiers changed from: protected */
+            @Override // java.lang.ThreadLocal
+            public ArrayList<LockGraphNode> initialValue() {
+                return Lists.b(3);
+            }
+        };
+    }
+}

sources/com/google/common/util/concurrent/ExecutionError.java

@@ -0,0 +1,21 @@
+package com.google.common.util.concurrent;
+
+/* loaded from: classes.dex */
+public class ExecutionError extends Error {
+    private static final long serialVersionUID = 0;
+
+    protected ExecutionError() {
+    }
+
+    protected ExecutionError(String str) {
+        super(str);
+    }
+
+    public ExecutionError(String str, Error error) {
+        super(str, error);
+    }
+
+    public ExecutionError(Error error) {
+        super(error);
+    }
+}

sources/com/google/common/util/concurrent/Service$State.java

@@ -0,0 +1,43 @@
+package com.google.common.util.concurrent;
+
+/* loaded from: classes.dex */
+public enum Service$State {
+    NEW { // from class: com.google.common.util.concurrent.Service$State.1
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return false;
+        }
+    },
+    STARTING { // from class: com.google.common.util.concurrent.Service$State.2
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return false;
+        }
+    },
+    RUNNING { // from class: com.google.common.util.concurrent.Service$State.3
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return false;
+        }
+    },
+    STOPPING { // from class: com.google.common.util.concurrent.Service$State.4
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return false;
+        }
+    },
+    TERMINATED { // from class: com.google.common.util.concurrent.Service$State.5
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return true;
+        }
+    },
+    FAILED { // from class: com.google.common.util.concurrent.Service$State.6
+        @Override // com.google.common.util.concurrent.Service$State
+        boolean isTerminal() {
+            return true;
+        }
+    };
+
+    abstract boolean isTerminal();
+}

sources/com/google/common/util/concurrent/UncheckedExecutionException.java

@@ -0,0 +1,21 @@
+package com.google.common.util.concurrent;
+
+/* loaded from: classes.dex */
+public class UncheckedExecutionException extends RuntimeException {
+    private static final long serialVersionUID = 0;
+
+    protected UncheckedExecutionException() {
+    }
+
+    protected UncheckedExecutionException(String str) {
+        super(str);
+    }
+
+    public UncheckedExecutionException(String str, Throwable th) {
+        super(str, th);
+    }
+
+    public UncheckedExecutionException(Throwable th) {
+        super(th);
+    }
+}

sources/com/google/common/util/concurrent/UncheckedTimeoutException.java

@@ -0,0 +1,21 @@
+package com.google.common.util.concurrent;
+
+/* loaded from: classes.dex */
+public class UncheckedTimeoutException extends RuntimeException {
+    private static final long serialVersionUID = 0;
+
+    public UncheckedTimeoutException() {
+    }
+
+    public UncheckedTimeoutException(String str) {
+        super(str);
+    }
+
+    public UncheckedTimeoutException(Throwable th) {
+        super(th);
+    }
+
+    public UncheckedTimeoutException(String str, Throwable th) {
+        super(str, th);
+    }
+}