Initial commit

sources/androidx/arch/core/executor/ArchTaskExecutor.java

@@ -0,0 +1,55 @@
+package androidx.arch.core.executor;
+
+import java.util.concurrent.Executor;
+
+/* loaded from: classes.dex */
+public class ArchTaskExecutor extends TaskExecutor {
+    private static volatile ArchTaskExecutor c;
+    private TaskExecutor b = new DefaultTaskExecutor();
+    private TaskExecutor a = this.b;
+
+    static {
+        new Executor() { // from class: androidx.arch.core.executor.ArchTaskExecutor.1
+            @Override // java.util.concurrent.Executor
+            public void execute(Runnable runnable) {
+                ArchTaskExecutor.b().b(runnable);
+            }
+        };
+        new Executor() { // from class: androidx.arch.core.executor.ArchTaskExecutor.2
+            @Override // java.util.concurrent.Executor
+            public void execute(Runnable runnable) {
+                ArchTaskExecutor.b().a(runnable);
+            }
+        };
+    }
+
+    private ArchTaskExecutor() {
+    }
+
+    public static ArchTaskExecutor b() {
+        if (c != null) {
+            return c;
+        }
+        synchronized (ArchTaskExecutor.class) {
+            if (c == null) {
+                c = new ArchTaskExecutor();
+            }
+        }
+        return c;
+    }
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public void a(Runnable runnable) {
+        this.a.a(runnable);
+    }
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public boolean a() {
+        return this.a.a();
+    }
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public void b(Runnable runnable) {
+        this.a.b(runnable);
+    }
+}

sources/androidx/arch/core/executor/DefaultTaskExecutor.java

@@ -0,0 +1,46 @@
+package androidx.arch.core.executor;
+
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes.dex */
+public class DefaultTaskExecutor extends TaskExecutor {
+    private final Object a = new Object();
+    private final ExecutorService b = Executors.newFixedThreadPool(2, new ThreadFactory(this) { // from class: androidx.arch.core.executor.DefaultTaskExecutor.1
+        private final AtomicInteger a = new AtomicInteger(0);
+
+        @Override // java.util.concurrent.ThreadFactory
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable);
+            thread.setName(String.format("arch_disk_io_%d", Integer.valueOf(this.a.getAndIncrement())));
+            return thread;
+        }
+    });
+    private volatile Handler c;
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public void a(Runnable runnable) {
+        this.b.execute(runnable);
+    }
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public void b(Runnable runnable) {
+        if (this.c == null) {
+            synchronized (this.a) {
+                if (this.c == null) {
+                    this.c = new Handler(Looper.getMainLooper());
+                }
+            }
+        }
+        this.c.post(runnable);
+    }
+
+    @Override // androidx.arch.core.executor.TaskExecutor
+    public boolean a() {
+        return Looper.getMainLooper().getThread() == Thread.currentThread();
+    }
+}

sources/androidx/arch/core/executor/TaskExecutor.java

@@ -0,0 +1,10 @@
+package androidx.arch.core.executor;
+
+/* loaded from: classes.dex */
+public abstract class TaskExecutor {
+    public abstract void a(Runnable runnable);
+
+    public abstract boolean a();
+
+    public abstract void b(Runnable runnable);
+}

sources/androidx/arch/core/internal/FastSafeIterableMap.java

@@ -0,0 +1,43 @@
+package androidx.arch.core.internal;
+
+import androidx.arch.core.internal.SafeIterableMap;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class FastSafeIterableMap<K, V> extends SafeIterableMap<K, V> {
+    private HashMap<K, SafeIterableMap.Entry<K, V>> e = new HashMap<>();
+
+    @Override // androidx.arch.core.internal.SafeIterableMap
+    protected SafeIterableMap.Entry<K, V> a(K k) {
+        return this.e.get(k);
+    }
+
+    @Override // androidx.arch.core.internal.SafeIterableMap
+    public V b(K k, V v) {
+        SafeIterableMap.Entry<K, V> a = a(k);
+        if (a != null) {
+            return a.b;
+        }
+        this.e.put(k, a(k, v));
+        return null;
+    }
+
+    public boolean contains(K k) {
+        return this.e.containsKey(k);
+    }
+
+    @Override // androidx.arch.core.internal.SafeIterableMap
+    public V remove(K k) {
+        V v = (V) super.remove(k);
+        this.e.remove(k);
+        return v;
+    }
+
+    public Map.Entry<K, V> b(K k) {
+        if (contains(k)) {
+            return this.e.get(k).d;
+        }
+        return null;
+    }
+}

sources/androidx/arch/core/internal/SafeIterableMap.java

@@ -0,0 +1,324 @@
+package androidx.arch.core.internal;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public class SafeIterableMap<K, V> implements Iterable<Map.Entry<K, V>> {
+    Entry<K, V> a;
+    private Entry<K, V> b;
+    private WeakHashMap<SupportRemove<K, V>, Boolean> c = new WeakHashMap<>();
+    private int d = 0;
+
+    static class AscendingIterator<K, V> extends ListIterator<K, V> {
+        AscendingIterator(Entry<K, V> entry, Entry<K, V> entry2) {
+            super(entry, entry2);
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
+        Entry<K, V> b(Entry<K, V> entry) {
+            return entry.d;
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
+        Entry<K, V> c(Entry<K, V> entry) {
+            return entry.c;
+        }
+    }
+
+    private static class DescendingIterator<K, V> extends ListIterator<K, V> {
+        DescendingIterator(Entry<K, V> entry, Entry<K, V> entry2) {
+            super(entry, entry2);
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
+        Entry<K, V> b(Entry<K, V> entry) {
+            return entry.c;
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
+        Entry<K, V> c(Entry<K, V> entry) {
+            return entry.d;
+        }
+    }
+
+    static class Entry<K, V> implements Map.Entry<K, V> {
+        final K a;
+        final V b;
+        Entry<K, V> c;
+        Entry<K, V> d;
+
+        Entry(K k, V v) {
+            this.a = k;
+            this.b = v;
+        }
+
+        @Override // java.util.Map.Entry
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof Entry)) {
+                return false;
+            }
+            Entry entry = (Entry) obj;
+            return this.a.equals(entry.a) && this.b.equals(entry.b);
+        }
+
+        @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 int hashCode() {
+            return this.a.hashCode() ^ this.b.hashCode();
+        }
+
+        @Override // java.util.Map.Entry
+        public V setValue(V v) {
+            throw new UnsupportedOperationException("An entry modification is not supported");
+        }
+
+        public String toString() {
+            return this.a + "=" + this.b;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public class IteratorWithAdditions implements Iterator<Map.Entry<K, V>>, SupportRemove<K, V> {
+        private Entry<K, V> a;
+        private boolean b = true;
+
+        IteratorWithAdditions() {
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.SupportRemove
+        public void a(Entry<K, V> entry) {
+            Entry<K, V> entry2 = this.a;
+            if (entry == entry2) {
+                this.a = entry2.d;
+                this.b = this.a == null;
+            }
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            if (this.b) {
+                return SafeIterableMap.this.a != null;
+            }
+            Entry<K, V> entry = this.a;
+            return (entry == null || entry.c == null) ? false : true;
+        }
+
+        @Override // java.util.Iterator
+        public Map.Entry<K, V> next() {
+            if (this.b) {
+                this.b = false;
+                this.a = SafeIterableMap.this.a;
+            } else {
+                Entry<K, V> entry = this.a;
+                this.a = entry != null ? entry.c : null;
+            }
+            return this.a;
+        }
+    }
+
+    private static abstract class ListIterator<K, V> implements Iterator<Map.Entry<K, V>>, SupportRemove<K, V> {
+        Entry<K, V> a;
+        Entry<K, V> b;
+
+        ListIterator(Entry<K, V> entry, Entry<K, V> entry2) {
+            this.a = entry2;
+            this.b = entry;
+        }
+
+        @Override // androidx.arch.core.internal.SafeIterableMap.SupportRemove
+        public void a(Entry<K, V> entry) {
+            if (this.a == entry && entry == this.b) {
+                this.b = null;
+                this.a = null;
+            }
+            Entry<K, V> entry2 = this.a;
+            if (entry2 == entry) {
+                this.a = b(entry2);
+            }
+            if (this.b == entry) {
+                this.b = a();
+            }
+        }
+
+        abstract Entry<K, V> b(Entry<K, V> entry);
+
+        abstract Entry<K, V> c(Entry<K, V> entry);
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            return this.b != null;
+        }
+
+        @Override // java.util.Iterator
+        public Map.Entry<K, V> next() {
+            Entry<K, V> entry = this.b;
+            this.b = a();
+            return entry;
+        }
+
+        private Entry<K, V> a() {
+            Entry<K, V> entry = this.b;
+            Entry<K, V> entry2 = this.a;
+            if (entry == entry2 || entry2 == null) {
+                return null;
+            }
+            return c(entry);
+        }
+    }
+
+    interface SupportRemove<K, V> {
+        void a(Entry<K, V> entry);
+    }
+
+    protected Entry<K, V> a(K k) {
+        Entry<K, V> entry = this.a;
+        while (entry != null && !entry.a.equals(k)) {
+            entry = entry.c;
+        }
+        return entry;
+    }
+
+    public V b(K k, V v) {
+        Entry<K, V> a = a(k);
+        if (a != null) {
+            return a.b;
+        }
+        a(k, v);
+        return null;
+    }
+
+    public Map.Entry<K, V> d() {
+        return this.b;
+    }
+
+    public Iterator<Map.Entry<K, V>> descendingIterator() {
+        DescendingIterator descendingIterator = new DescendingIterator(this.b, this.a);
+        this.c.put(descendingIterator, false);
+        return descendingIterator;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof SafeIterableMap)) {
+            return false;
+        }
+        SafeIterableMap safeIterableMap = (SafeIterableMap) obj;
+        if (size() != safeIterableMap.size()) {
+            return false;
+        }
+        Iterator<Map.Entry<K, V>> it = iterator();
+        Iterator<Map.Entry<K, V>> it2 = safeIterableMap.iterator();
+        while (it.hasNext() && it2.hasNext()) {
+            Map.Entry<K, V> next = it.next();
+            Map.Entry<K, V> next2 = it2.next();
+            if ((next == null && next2 != null) || (next != null && !next.equals(next2))) {
+                return false;
+            }
+        }
+        return (it.hasNext() || it2.hasNext()) ? false : true;
+    }
+
+    public int hashCode() {
+        Iterator<Map.Entry<K, V>> it = iterator();
+        int i = 0;
+        while (it.hasNext()) {
+            i += it.next().hashCode();
+        }
+        return i;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator<Map.Entry<K, V>> iterator() {
+        AscendingIterator ascendingIterator = new AscendingIterator(this.a, this.b);
+        this.c.put(ascendingIterator, false);
+        return ascendingIterator;
+    }
+
+    public V remove(K k) {
+        Entry<K, V> a = a(k);
+        if (a == null) {
+            return null;
+        }
+        this.d--;
+        if (!this.c.isEmpty()) {
+            Iterator<SupportRemove<K, V>> it = this.c.keySet().iterator();
+            while (it.hasNext()) {
+                it.next().a(a);
+            }
+        }
+        Entry<K, V> entry = a.d;
+        if (entry != null) {
+            entry.c = a.c;
+        } else {
+            this.a = a.c;
+        }
+        Entry<K, V> entry2 = a.c;
+        if (entry2 != null) {
+            entry2.d = a.d;
+        } else {
+            this.b = a.d;
+        }
+        a.c = null;
+        a.d = null;
+        return a.b;
+    }
+
+    public int size() {
+        return this.d;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+        Iterator<Map.Entry<K, V>> it = iterator();
+        while (it.hasNext()) {
+            sb.append(it.next().toString());
+            if (it.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    protected Entry<K, V> a(K k, V v) {
+        Entry<K, V> entry = new Entry<>(k, v);
+        this.d++;
+        Entry<K, V> entry2 = this.b;
+        if (entry2 == null) {
+            this.a = entry;
+            this.b = this.a;
+            return entry;
+        }
+        entry2.c = entry;
+        entry.d = entry2;
+        this.b = entry;
+        return entry;
+    }
+
+    public SafeIterableMap<K, V>.IteratorWithAdditions b() {
+        SafeIterableMap<K, V>.IteratorWithAdditions iteratorWithAdditions = new IteratorWithAdditions();
+        this.c.put(iteratorWithAdditions, false);
+        return iteratorWithAdditions;
+    }
+
+    public Map.Entry<K, V> a() {
+        return this.a;
+    }
+}