593 lines
17 KiB
Java
593 lines
17 KiB
Java
package com.google.gson.internal;
|
|
|
|
import java.io.ObjectStreamException;
|
|
import java.io.Serializable;
|
|
import java.util.AbstractMap;
|
|
import java.util.AbstractSet;
|
|
import java.util.Comparator;
|
|
import java.util.ConcurrentModificationException;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
public final class LinkedTreeMap<K, V> extends AbstractMap<K, V> implements Serializable {
|
|
public static final Comparator<Comparable> i = new a();
|
|
public Comparator<? super K> comparator;
|
|
private LinkedTreeMap<K, V>.b entrySet;
|
|
public final e<K, V> header = new e<>();
|
|
private LinkedTreeMap<K, V>.c keySet;
|
|
public int modCount = 0;
|
|
public e<K, V> root;
|
|
public int size = 0;
|
|
|
|
public class a implements Comparator<Comparable> {
|
|
/* JADX DEBUG: Method arguments types fixed to match base method, original types: [java.lang.Object, java.lang.Object] */
|
|
@Override // java.util.Comparator
|
|
public int compare(Comparable comparable, Comparable comparable2) {
|
|
return comparable.compareTo(comparable2);
|
|
}
|
|
}
|
|
|
|
public class b extends AbstractSet<Map.Entry<K, V>> {
|
|
|
|
public class a extends LinkedTreeMap<K, V>.d {
|
|
public a(b bVar) {
|
|
super();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public Object next() {
|
|
return a();
|
|
}
|
|
}
|
|
|
|
public b() {
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public void clear() {
|
|
LinkedTreeMap.this.clear();
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean contains(Object obj) {
|
|
return (obj instanceof Map.Entry) && LinkedTreeMap.this.b((Map.Entry) obj) != null;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set, java.lang.Iterable
|
|
public Iterator<Map.Entry<K, V>> iterator() {
|
|
return new a(this);
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean remove(Object obj) {
|
|
e<K, V> b;
|
|
if (!(obj instanceof Map.Entry) || (b = LinkedTreeMap.this.b((Map.Entry) obj)) == null) {
|
|
return false;
|
|
}
|
|
LinkedTreeMap.this.e(b, true);
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public int size() {
|
|
return LinkedTreeMap.this.size;
|
|
}
|
|
}
|
|
|
|
public final class c extends AbstractSet<K> {
|
|
|
|
public class a extends LinkedTreeMap<K, V>.d {
|
|
public a(c cVar) {
|
|
super();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public K next() {
|
|
return a().n;
|
|
}
|
|
}
|
|
|
|
public c() {
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public void clear() {
|
|
LinkedTreeMap.this.clear();
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean contains(Object obj) {
|
|
return LinkedTreeMap.this.c(obj) != null;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set, java.lang.Iterable
|
|
public Iterator<K> iterator() {
|
|
return new a(this);
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public boolean remove(Object obj) {
|
|
LinkedTreeMap linkedTreeMap = LinkedTreeMap.this;
|
|
e<K, V> c2 = linkedTreeMap.c(obj);
|
|
if (c2 != null) {
|
|
linkedTreeMap.e(c2, true);
|
|
}
|
|
return c2 != null;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
|
public int size() {
|
|
return LinkedTreeMap.this.size;
|
|
}
|
|
}
|
|
|
|
public abstract class d<T> implements Iterator<T> {
|
|
public e<K, V> i;
|
|
public e<K, V> j = null;
|
|
public int k;
|
|
|
|
public d() {
|
|
this.i = LinkedTreeMap.this.header.l;
|
|
this.k = LinkedTreeMap.this.modCount;
|
|
}
|
|
|
|
public final e<K, V> a() {
|
|
e<K, V> eVar = this.i;
|
|
LinkedTreeMap linkedTreeMap = LinkedTreeMap.this;
|
|
if (eVar == linkedTreeMap.header) {
|
|
throw new NoSuchElementException();
|
|
} else if (linkedTreeMap.modCount == this.k) {
|
|
this.i = eVar.l;
|
|
this.j = eVar;
|
|
return eVar;
|
|
} else {
|
|
throw new ConcurrentModificationException();
|
|
}
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public final boolean hasNext() {
|
|
return this.i != LinkedTreeMap.this.header;
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public final void remove() {
|
|
e<K, V> eVar = this.j;
|
|
if (eVar != null) {
|
|
LinkedTreeMap.this.e(eVar, true);
|
|
this.j = null;
|
|
this.k = LinkedTreeMap.this.modCount;
|
|
return;
|
|
}
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
|
|
public static final class e<K, V> implements Map.Entry<K, V> {
|
|
public e<K, V> i;
|
|
public e<K, V> j;
|
|
public e<K, V> k;
|
|
public e<K, V> l;
|
|
public e<K, V> m;
|
|
public final K n;
|
|
public V o;
|
|
public int p;
|
|
|
|
public e() {
|
|
this.n = null;
|
|
this.m = this;
|
|
this.l = this;
|
|
}
|
|
|
|
public e(e<K, V> eVar, K k, e<K, V> eVar2, e<K, V> eVar3) {
|
|
this.i = eVar;
|
|
this.n = k;
|
|
this.p = 1;
|
|
this.l = eVar2;
|
|
this.m = eVar3;
|
|
eVar3.l = this;
|
|
eVar2.m = this;
|
|
}
|
|
|
|
@Override // java.util.Map.Entry, java.lang.Object
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof Map.Entry)) {
|
|
return false;
|
|
}
|
|
Map.Entry entry = (Map.Entry) obj;
|
|
K k = this.n;
|
|
if (k == null) {
|
|
if (entry.getKey() != null) {
|
|
return false;
|
|
}
|
|
} else if (!k.equals(entry.getKey())) {
|
|
return false;
|
|
}
|
|
V v = this.o;
|
|
if (v == null) {
|
|
if (entry.getValue() != null) {
|
|
return false;
|
|
}
|
|
} else if (!v.equals(entry.getValue())) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public K getKey() {
|
|
return this.n;
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public V getValue() {
|
|
return this.o;
|
|
}
|
|
|
|
@Override // java.util.Map.Entry, java.lang.Object
|
|
public int hashCode() {
|
|
K k = this.n;
|
|
int i = 0;
|
|
int hashCode = k == null ? 0 : k.hashCode();
|
|
V v = this.o;
|
|
if (v != null) {
|
|
i = v.hashCode();
|
|
}
|
|
return hashCode ^ i;
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public V setValue(V v) {
|
|
V v2 = this.o;
|
|
this.o = v;
|
|
return v2;
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public String toString() {
|
|
return ((Object) this.n) + "=" + ((Object) this.o);
|
|
}
|
|
}
|
|
|
|
public LinkedTreeMap() {
|
|
Comparator<Comparable> comparator = i;
|
|
this.comparator = comparator;
|
|
}
|
|
|
|
private Object writeReplace() throws ObjectStreamException {
|
|
return new LinkedHashMap(this);
|
|
}
|
|
|
|
public e<K, V> a(K k, boolean z2) {
|
|
int i2;
|
|
e<K, V> eVar;
|
|
Comparator<? super K> comparator = this.comparator;
|
|
e<K, V> eVar2 = this.root;
|
|
if (eVar2 != null) {
|
|
K k2 = comparator == i ? k : null;
|
|
while (true) {
|
|
i2 = k2 != null ? k2.compareTo(eVar2.n) : comparator.compare(k, eVar2.n);
|
|
if (i2 == 0) {
|
|
return eVar2;
|
|
}
|
|
e<K, V> eVar3 = i2 < 0 ? eVar2.j : eVar2.k;
|
|
if (eVar3 == null) {
|
|
break;
|
|
}
|
|
eVar2 = eVar3;
|
|
}
|
|
} else {
|
|
i2 = 0;
|
|
}
|
|
if (!z2) {
|
|
return null;
|
|
}
|
|
e<K, V> eVar4 = this.header;
|
|
if (eVar2 != null) {
|
|
eVar = new e<>(eVar2, k, eVar4, eVar4.m);
|
|
if (i2 < 0) {
|
|
eVar2.j = eVar;
|
|
} else {
|
|
eVar2.k = eVar;
|
|
}
|
|
d(eVar2, true);
|
|
} else if (comparator != i || (k instanceof Comparable)) {
|
|
eVar = new e<>(eVar2, k, eVar4, eVar4.m);
|
|
this.root = eVar;
|
|
} else {
|
|
throw new ClassCastException(k.getClass().getName() + " is not Comparable");
|
|
}
|
|
this.size++;
|
|
this.modCount++;
|
|
return eVar;
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:9:0x0020, code lost:
|
|
if ((r3 == r5 || (r3 != null && r3.equals(r5))) != false) goto L_0x0024;
|
|
*/
|
|
public e<K, V> b(Map.Entry<?, ?> entry) {
|
|
e<K, V> c2 = c(entry.getKey());
|
|
boolean z2 = true;
|
|
if (c2 != null) {
|
|
V v = c2.o;
|
|
Object value = entry.getValue();
|
|
}
|
|
z2 = false;
|
|
if (z2) {
|
|
return c2;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r3v0, resolved type: java.lang.Object */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public e<K, V> c(Object obj) {
|
|
if (obj == 0) {
|
|
return null;
|
|
}
|
|
try {
|
|
return a(obj, false);
|
|
} catch (ClassCastException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public void clear() {
|
|
this.root = null;
|
|
this.size = 0;
|
|
this.modCount++;
|
|
e<K, V> eVar = this.header;
|
|
eVar.m = eVar;
|
|
eVar.l = eVar;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public boolean containsKey(Object obj) {
|
|
return c(obj) != null;
|
|
}
|
|
|
|
public final void d(e<K, V> eVar, boolean z2) {
|
|
while (eVar != null) {
|
|
e<K, V> eVar2 = eVar.j;
|
|
e<K, V> eVar3 = eVar.k;
|
|
int i2 = 0;
|
|
int i3 = eVar2 != null ? eVar2.p : 0;
|
|
int i4 = eVar3 != null ? eVar3.p : 0;
|
|
int i5 = i3 - i4;
|
|
if (i5 == -2) {
|
|
e<K, V> eVar4 = eVar3.j;
|
|
e<K, V> eVar5 = eVar3.k;
|
|
int i6 = eVar5 != null ? eVar5.p : 0;
|
|
if (eVar4 != null) {
|
|
i2 = eVar4.p;
|
|
}
|
|
int i7 = i2 - i6;
|
|
if (i7 == -1 || (i7 == 0 && !z2)) {
|
|
g(eVar);
|
|
} else {
|
|
h(eVar3);
|
|
g(eVar);
|
|
}
|
|
if (z2) {
|
|
return;
|
|
}
|
|
} else if (i5 == 2) {
|
|
e<K, V> eVar6 = eVar2.j;
|
|
e<K, V> eVar7 = eVar2.k;
|
|
int i8 = eVar7 != null ? eVar7.p : 0;
|
|
if (eVar6 != null) {
|
|
i2 = eVar6.p;
|
|
}
|
|
int i9 = i2 - i8;
|
|
if (i9 == 1 || (i9 == 0 && !z2)) {
|
|
h(eVar);
|
|
} else {
|
|
g(eVar2);
|
|
h(eVar);
|
|
}
|
|
if (z2) {
|
|
return;
|
|
}
|
|
} else if (i5 == 0) {
|
|
eVar.p = i3 + 1;
|
|
if (z2) {
|
|
return;
|
|
}
|
|
} else {
|
|
eVar.p = Math.max(i3, i4) + 1;
|
|
if (!z2) {
|
|
return;
|
|
}
|
|
}
|
|
eVar = eVar.i;
|
|
}
|
|
}
|
|
|
|
public void e(e<K, V> eVar, boolean z2) {
|
|
e<K, V> eVar2;
|
|
int i2;
|
|
if (z2) {
|
|
e<K, V> eVar3 = eVar.m;
|
|
eVar3.l = eVar.l;
|
|
eVar.l.m = eVar3;
|
|
}
|
|
e<K, V> eVar4 = eVar.j;
|
|
e<K, V> eVar5 = eVar.k;
|
|
e<K, V> eVar6 = eVar.i;
|
|
int i3 = 0;
|
|
if (eVar4 == null || eVar5 == null) {
|
|
if (eVar4 != null) {
|
|
f(eVar, eVar4);
|
|
eVar.j = null;
|
|
} else if (eVar5 != null) {
|
|
f(eVar, eVar5);
|
|
eVar.k = null;
|
|
} else {
|
|
f(eVar, null);
|
|
}
|
|
d(eVar6, false);
|
|
this.size--;
|
|
this.modCount++;
|
|
return;
|
|
}
|
|
if (eVar4.p > eVar5.p) {
|
|
e<K, V> eVar7 = eVar4.k;
|
|
while (true) {
|
|
eVar2 = eVar4;
|
|
eVar4 = eVar7;
|
|
if (eVar4 == null) {
|
|
break;
|
|
}
|
|
eVar7 = eVar4.k;
|
|
}
|
|
} else {
|
|
e<K, V> eVar8 = eVar5.j;
|
|
while (true) {
|
|
eVar5 = eVar8;
|
|
if (eVar5 == null) {
|
|
break;
|
|
}
|
|
eVar8 = eVar5.j;
|
|
}
|
|
eVar2 = eVar5;
|
|
}
|
|
e(eVar2, false);
|
|
e<K, V> eVar9 = eVar.j;
|
|
if (eVar9 != null) {
|
|
i2 = eVar9.p;
|
|
eVar2.j = eVar9;
|
|
eVar9.i = eVar2;
|
|
eVar.j = null;
|
|
} else {
|
|
i2 = 0;
|
|
}
|
|
e<K, V> eVar10 = eVar.k;
|
|
if (eVar10 != null) {
|
|
i3 = eVar10.p;
|
|
eVar2.k = eVar10;
|
|
eVar10.i = eVar2;
|
|
eVar.k = null;
|
|
}
|
|
eVar2.p = Math.max(i2, i3) + 1;
|
|
f(eVar, eVar2);
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public Set<Map.Entry<K, V>> entrySet() {
|
|
LinkedTreeMap<K, V>.b bVar = this.entrySet;
|
|
if (bVar != null) {
|
|
return bVar;
|
|
}
|
|
LinkedTreeMap<K, V>.b bVar2 = new b();
|
|
this.entrySet = bVar2;
|
|
return bVar2;
|
|
}
|
|
|
|
public final void f(e<K, V> eVar, e<K, V> eVar2) {
|
|
e<K, V> eVar3 = eVar.i;
|
|
eVar.i = null;
|
|
if (eVar2 != null) {
|
|
eVar2.i = eVar3;
|
|
}
|
|
if (eVar3 == null) {
|
|
this.root = eVar2;
|
|
} else if (eVar3.j == eVar) {
|
|
eVar3.j = eVar2;
|
|
} else {
|
|
eVar3.k = eVar2;
|
|
}
|
|
}
|
|
|
|
public final void g(e<K, V> eVar) {
|
|
e<K, V> eVar2 = eVar.j;
|
|
e<K, V> eVar3 = eVar.k;
|
|
e<K, V> eVar4 = eVar3.j;
|
|
e<K, V> eVar5 = eVar3.k;
|
|
eVar.k = eVar4;
|
|
if (eVar4 != null) {
|
|
eVar4.i = eVar;
|
|
}
|
|
f(eVar, eVar3);
|
|
eVar3.j = eVar;
|
|
eVar.i = eVar3;
|
|
int i2 = 0;
|
|
int max = Math.max(eVar2 != null ? eVar2.p : 0, eVar4 != null ? eVar4.p : 0) + 1;
|
|
eVar.p = max;
|
|
if (eVar5 != null) {
|
|
i2 = eVar5.p;
|
|
}
|
|
eVar3.p = Math.max(max, i2) + 1;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public V get(Object obj) {
|
|
e<K, V> c2 = c(obj);
|
|
if (c2 != null) {
|
|
return c2.o;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final void h(e<K, V> eVar) {
|
|
e<K, V> eVar2 = eVar.j;
|
|
e<K, V> eVar3 = eVar.k;
|
|
e<K, V> eVar4 = eVar2.j;
|
|
e<K, V> eVar5 = eVar2.k;
|
|
eVar.j = eVar5;
|
|
if (eVar5 != null) {
|
|
eVar5.i = eVar;
|
|
}
|
|
f(eVar, eVar2);
|
|
eVar2.k = eVar;
|
|
eVar.i = eVar2;
|
|
int i2 = 0;
|
|
int max = Math.max(eVar3 != null ? eVar3.p : 0, eVar5 != null ? eVar5.p : 0) + 1;
|
|
eVar.p = max;
|
|
if (eVar4 != null) {
|
|
i2 = eVar4.p;
|
|
}
|
|
eVar2.p = Math.max(max, i2) + 1;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public Set<K> keySet() {
|
|
LinkedTreeMap<K, V>.c cVar = this.keySet;
|
|
if (cVar != null) {
|
|
return cVar;
|
|
}
|
|
LinkedTreeMap<K, V>.c cVar2 = new c();
|
|
this.keySet = cVar2;
|
|
return cVar2;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public V put(K k, V v) {
|
|
Objects.requireNonNull(k, "key == null");
|
|
e<K, V> a2 = a(k, true);
|
|
V v2 = a2.o;
|
|
a2.o = v;
|
|
return v2;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public V remove(Object obj) {
|
|
e<K, V> c2 = c(obj);
|
|
if (c2 != null) {
|
|
e(c2, true);
|
|
}
|
|
if (c2 != null) {
|
|
return c2.o;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // java.util.AbstractMap, java.util.Map
|
|
public int size() {
|
|
return this.size;
|
|
}
|
|
}
|