593 lines
19 KiB
Java
593 lines
19 KiB
Java
|
package com.google.gson.internal;
|
||
|
|
|
||
|
|
import com.huawei.hms.framework.common.ContainerUtils;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.InvalidObjectException;
|
||
|
|
import java.io.ObjectInputStream;
|
||
|
|
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.Set;
|
||
|
|
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public final class LinkedTreeMap<K, V> extends AbstractMap<K, V> implements Serializable {
|
||
|
|
static final boolean $assertionsDisabled = false;
|
||
|
|
private static final Comparator<Comparable> NATURAL_ORDER = new Comparator<Comparable>() { // from class: com.google.gson.internal.LinkedTreeMap.1
|
||
|
|
@Override // java.util.Comparator
|
||
|
|
public int compare(Comparable comparable, Comparable comparable2) {
|
||
|
|
return comparable.compareTo(comparable2);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Comparator<? super K> comparator;
|
||
|
|
private LinkedTreeMap<K, V>.EntrySet entrySet;
|
||
|
|
final Node<K, V> header;
|
||
|
|
private LinkedTreeMap<K, V>.KeySet keySet;
|
||
|
|
int modCount;
|
||
|
|
Node<K, V> root;
|
||
|
|
int size;
|
||
|
|
|
||
|
|
public LinkedTreeMap() {
|
||
|
|
this(NATURAL_ORDER);
|
||
|
|
}
|
||
|
|
|
||
|
|
public LinkedTreeMap(Comparator<? super K> comparator) {
|
||
|
|
this.size = 0;
|
||
|
|
this.modCount = 0;
|
||
|
|
this.header = new Node<>();
|
||
|
|
this.comparator = comparator == null ? NATURAL_ORDER : comparator;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final V get(Object obj) {
|
||
|
|
Node<K, V> findByObject = findByObject(obj);
|
||
|
|
if (findByObject != null) {
|
||
|
|
return findByObject.value;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final boolean containsKey(Object obj) {
|
||
|
|
return findByObject(obj) != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final V put(K k, V v) {
|
||
|
|
if (k == null) {
|
||
|
|
throw new NullPointerException("key == null");
|
||
|
|
}
|
||
|
|
Node<K, V> find = find(k, true);
|
||
|
|
V v2 = find.value;
|
||
|
|
find.value = v;
|
||
|
|
return v2;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final void clear() {
|
||
|
|
this.root = null;
|
||
|
|
this.size = 0;
|
||
|
|
this.modCount++;
|
||
|
|
Node<K, V> node = this.header;
|
||
|
|
node.prev = node;
|
||
|
|
node.next = node;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final V remove(Object obj) {
|
||
|
|
Node<K, V> removeInternalByKey = removeInternalByKey(obj);
|
||
|
|
if (removeInternalByKey != null) {
|
||
|
|
return removeInternalByKey.value;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
final Node<K, V> find(K k, boolean z) {
|
||
|
|
int i;
|
||
|
|
Node<K, V> node;
|
||
|
|
Comparator<? super K> comparator = this.comparator;
|
||
|
|
Node<K, V> node2 = this.root;
|
||
|
|
if (node2 != null) {
|
||
|
|
Comparable comparable = comparator == NATURAL_ORDER ? (Comparable) k : null;
|
||
|
|
while (true) {
|
||
|
|
if (comparable != null) {
|
||
|
|
i = comparable.compareTo(node2.key);
|
||
|
|
} else {
|
||
|
|
i = comparator.compare(k, node2.key);
|
||
|
|
}
|
||
|
|
if (i != 0) {
|
||
|
|
Node<K, V> node3 = i < 0 ? node2.left : node2.right;
|
||
|
|
if (node3 == null) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
node2 = node3;
|
||
|
|
} else {
|
||
|
|
return node2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
if (!z) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
Node<K, V> node4 = this.header;
|
||
|
|
if (node2 == null) {
|
||
|
|
if (comparator == NATURAL_ORDER && !(k instanceof Comparable)) {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(k.getClass().getName());
|
||
|
|
sb.append(" is not Comparable");
|
||
|
|
throw new ClassCastException(sb.toString());
|
||
|
|
}
|
||
|
|
node = new Node<>(node2, k, node4, node4.prev);
|
||
|
|
this.root = node;
|
||
|
|
} else {
|
||
|
|
node = new Node<>(node2, k, node4, node4.prev);
|
||
|
|
if (i < 0) {
|
||
|
|
node2.left = node;
|
||
|
|
} else {
|
||
|
|
node2.right = node;
|
||
|
|
}
|
||
|
|
rebalance(node2, true);
|
||
|
|
}
|
||
|
|
this.size++;
|
||
|
|
this.modCount++;
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX WARN: Multi-variable type inference failed */
|
||
|
|
final Node<K, V> findByObject(Object obj) {
|
||
|
|
if (obj == 0) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
return find(obj, false);
|
||
|
|
} catch (ClassCastException unused) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
final Node<K, V> findByEntry(Map.Entry<?, ?> entry) {
|
||
|
|
Node<K, V> findByObject = findByObject(entry.getKey());
|
||
|
|
if (findByObject == null || !equal(findByObject.value, entry.getValue())) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return findByObject;
|
||
|
|
}
|
||
|
|
|
||
|
|
private boolean equal(Object obj, Object obj2) {
|
||
|
|
return obj == obj2 || (obj != null && obj.equals(obj2));
|
||
|
|
}
|
||
|
|
|
||
|
|
final void removeInternal(Node<K, V> node, boolean z) {
|
||
|
|
int i;
|
||
|
|
if (z) {
|
||
|
|
node.prev.next = node.next;
|
||
|
|
node.next.prev = node.prev;
|
||
|
|
}
|
||
|
|
Node<K, V> node2 = node.left;
|
||
|
|
Node<K, V> node3 = node.right;
|
||
|
|
Node<K, V> node4 = node.parent;
|
||
|
|
int i2 = 0;
|
||
|
|
if (node2 != null && node3 != null) {
|
||
|
|
Node<K, V> last = node2.height > node3.height ? node2.last() : node3.first();
|
||
|
|
removeInternal(last, false);
|
||
|
|
Node<K, V> node5 = node.left;
|
||
|
|
if (node5 != null) {
|
||
|
|
i = node5.height;
|
||
|
|
last.left = node5;
|
||
|
|
node5.parent = last;
|
||
|
|
node.left = null;
|
||
|
|
} else {
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
Node<K, V> node6 = node.right;
|
||
|
|
if (node6 != null) {
|
||
|
|
i2 = node6.height;
|
||
|
|
last.right = node6;
|
||
|
|
node6.parent = last;
|
||
|
|
node.right = null;
|
||
|
|
}
|
||
|
|
last.height = Math.max(i, i2) + 1;
|
||
|
|
replaceInParent(node, last);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (node2 != null) {
|
||
|
|
replaceInParent(node, node2);
|
||
|
|
node.left = null;
|
||
|
|
} else if (node3 != null) {
|
||
|
|
replaceInParent(node, node3);
|
||
|
|
node.right = null;
|
||
|
|
} else {
|
||
|
|
replaceInParent(node, null);
|
||
|
|
}
|
||
|
|
rebalance(node4, false);
|
||
|
|
this.size--;
|
||
|
|
this.modCount++;
|
||
|
|
}
|
||
|
|
|
||
|
|
final Node<K, V> removeInternalByKey(Object obj) {
|
||
|
|
Node<K, V> findByObject = findByObject(obj);
|
||
|
|
if (findByObject != null) {
|
||
|
|
removeInternal(findByObject, true);
|
||
|
|
}
|
||
|
|
return findByObject;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void replaceInParent(Node<K, V> node, Node<K, V> node2) {
|
||
|
|
Node<K, V> node3 = node.parent;
|
||
|
|
node.parent = null;
|
||
|
|
if (node2 != null) {
|
||
|
|
node2.parent = node3;
|
||
|
|
}
|
||
|
|
if (node3 == null) {
|
||
|
|
this.root = node2;
|
||
|
|
} else if (node3.left == node) {
|
||
|
|
node3.left = node2;
|
||
|
|
} else {
|
||
|
|
node3.right = node2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void rebalance(Node<K, V> node, boolean z) {
|
||
|
|
while (node != null) {
|
||
|
|
Node<K, V> node2 = node.left;
|
||
|
|
Node<K, V> node3 = node.right;
|
||
|
|
int i = node2 != null ? node2.height : 0;
|
||
|
|
int i2 = node3 != null ? node3.height : 0;
|
||
|
|
int i3 = i - i2;
|
||
|
|
if (i3 == -2) {
|
||
|
|
Node<K, V> node4 = node3.left;
|
||
|
|
Node<K, V> node5 = node3.right;
|
||
|
|
int i4 = (node4 != null ? node4.height : 0) - (node5 != null ? node5.height : 0);
|
||
|
|
if (i4 != -1 && (i4 != 0 || z)) {
|
||
|
|
rotateRight(node3);
|
||
|
|
}
|
||
|
|
rotateLeft(node);
|
||
|
|
if (z) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else if (i3 == 2) {
|
||
|
|
Node<K, V> node6 = node2.left;
|
||
|
|
Node<K, V> node7 = node2.right;
|
||
|
|
int i5 = (node6 != null ? node6.height : 0) - (node7 != null ? node7.height : 0);
|
||
|
|
if (i5 != 1 && (i5 != 0 || z)) {
|
||
|
|
rotateLeft(node2);
|
||
|
|
}
|
||
|
|
rotateRight(node);
|
||
|
|
if (z) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else if (i3 == 0) {
|
||
|
|
node.height = i + 1;
|
||
|
|
if (z) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
node.height = Math.max(i, i2) + 1;
|
||
|
|
if (!z) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
node = node.parent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void rotateLeft(Node<K, V> node) {
|
||
|
|
Node<K, V> node2 = node.left;
|
||
|
|
Node<K, V> node3 = node.right;
|
||
|
|
Node<K, V> node4 = node3.left;
|
||
|
|
Node<K, V> node5 = node3.right;
|
||
|
|
node.right = node4;
|
||
|
|
if (node4 != null) {
|
||
|
|
node4.parent = node;
|
||
|
|
}
|
||
|
|
replaceInParent(node, node3);
|
||
|
|
node3.left = node;
|
||
|
|
node.parent = node3;
|
||
|
|
node.height = Math.max(node2 != null ? node2.height : 0, node4 != null ? node4.height : 0) + 1;
|
||
|
|
node3.height = Math.max(node.height, node5 != null ? node5.height : 0) + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void rotateRight(Node<K, V> node) {
|
||
|
|
Node<K, V> node2 = node.left;
|
||
|
|
Node<K, V> node3 = node.right;
|
||
|
|
Node<K, V> node4 = node2.left;
|
||
|
|
Node<K, V> node5 = node2.right;
|
||
|
|
node.left = node5;
|
||
|
|
if (node5 != null) {
|
||
|
|
node5.parent = node;
|
||
|
|
}
|
||
|
|
replaceInParent(node, node2);
|
||
|
|
node2.right = node;
|
||
|
|
node.parent = node2;
|
||
|
|
node.height = Math.max(node3 != null ? node3.height : 0, node5 != null ? node5.height : 0) + 1;
|
||
|
|
node2.height = Math.max(node.height, node4 != null ? node4.height : 0) + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final Set<Map.Entry<K, V>> entrySet() {
|
||
|
|
LinkedTreeMap<K, V>.EntrySet entrySet = this.entrySet;
|
||
|
|
if (entrySet != null) {
|
||
|
|
return entrySet;
|
||
|
|
}
|
||
|
|
LinkedTreeMap<K, V>.EntrySet entrySet2 = new EntrySet(this);
|
||
|
|
this.entrySet = entrySet2;
|
||
|
|
return entrySet2;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final Set<K> keySet() {
|
||
|
|
LinkedTreeMap<K, V>.KeySet keySet = this.keySet;
|
||
|
|
if (keySet != null) {
|
||
|
|
return keySet;
|
||
|
|
}
|
||
|
|
LinkedTreeMap<K, V>.KeySet keySet2 = new KeySet(this);
|
||
|
|
this.keySet = keySet2;
|
||
|
|
return keySet2;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public static final class Node<K, V> implements Map.Entry<K, V> {
|
||
|
|
int height;
|
||
|
|
final K key;
|
||
|
|
Node<K, V> left;
|
||
|
|
Node<K, V> next;
|
||
|
|
Node<K, V> parent;
|
||
|
|
Node<K, V> prev;
|
||
|
|
Node<K, V> right;
|
||
|
|
V value;
|
||
|
|
|
||
|
|
Node() {
|
||
|
|
this.key = null;
|
||
|
|
this.prev = this;
|
||
|
|
this.next = this;
|
||
|
|
}
|
||
|
|
|
||
|
|
Node(Node<K, V> node, K k, Node<K, V> node2, Node<K, V> node3) {
|
||
|
|
this.parent = node;
|
||
|
|
this.key = k;
|
||
|
|
this.height = 1;
|
||
|
|
this.next = node2;
|
||
|
|
this.prev = node3;
|
||
|
|
node3.next = this;
|
||
|
|
node2.prev = this;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Map.Entry
|
||
|
|
public final boolean equals(Object obj) {
|
||
|
|
if (!(obj instanceof Map.Entry)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
Map.Entry entry = (Map.Entry) obj;
|
||
|
|
K k = this.key;
|
||
|
|
if (k == null) {
|
||
|
|
if (entry.getKey() != null) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else if (!k.equals(entry.getKey())) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
V v = this.value;
|
||
|
|
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 final int hashCode() {
|
||
|
|
K k = this.key;
|
||
|
|
int hashCode = k == null ? 0 : k.hashCode();
|
||
|
|
V v = this.value;
|
||
|
|
return hashCode ^ (v != null ? v.hashCode() : 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
public final String toString() {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append(this.key);
|
||
|
|
sb.append(ContainerUtils.KEY_VALUE_DELIMITER);
|
||
|
|
sb.append(this.value);
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
public final Node<K, V> first() {
|
||
|
|
Node<K, V> node = this;
|
||
|
|
for (Node<K, V> node2 = this.left; node2 != null; node2 = node2.left) {
|
||
|
|
node = node2;
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
public final Node<K, V> last() {
|
||
|
|
Node<K, V> node = this;
|
||
|
|
for (Node<K, V> node2 = this.right; node2 != null; node2 = node2.right) {
|
||
|
|
node = node2;
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Map.Entry
|
||
|
|
public final V setValue(V v) {
|
||
|
|
V v2 = this.value;
|
||
|
|
this.value = v;
|
||
|
|
return v2;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Map.Entry
|
||
|
|
public final V getValue() {
|
||
|
|
return this.value;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Map.Entry
|
||
|
|
public final K getKey() {
|
||
|
|
return this.key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public abstract class LinkedTreeMapIterator<T> implements Iterator<T> {
|
||
|
|
int expectedModCount;
|
||
|
|
Node<K, V> lastReturned = null;
|
||
|
|
Node<K, V> next;
|
||
|
|
final LinkedTreeMap this$0;
|
||
|
|
|
||
|
|
LinkedTreeMapIterator(LinkedTreeMap linkedTreeMap) {
|
||
|
|
this.this$0 = linkedTreeMap;
|
||
|
|
this.next = linkedTreeMap.header.next;
|
||
|
|
this.expectedModCount = linkedTreeMap.modCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Iterator
|
||
|
|
public final boolean hasNext() {
|
||
|
|
return this.next != this.this$0.header;
|
||
|
|
}
|
||
|
|
|
||
|
|
final Node<K, V> nextNode() {
|
||
|
|
Node<K, V> node = this.next;
|
||
|
|
if (node == this.this$0.header) {
|
||
|
|
throw new NoSuchElementException();
|
||
|
|
}
|
||
|
|
if (this.this$0.modCount != this.expectedModCount) {
|
||
|
|
throw new ConcurrentModificationException();
|
||
|
|
}
|
||
|
|
this.next = node.next;
|
||
|
|
this.lastReturned = node;
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Iterator
|
||
|
|
public final void remove() {
|
||
|
|
Node<K, V> node = this.lastReturned;
|
||
|
|
if (node == null) {
|
||
|
|
throw new IllegalStateException();
|
||
|
|
}
|
||
|
|
this.this$0.removeInternal(node, true);
|
||
|
|
this.lastReturned = null;
|
||
|
|
this.expectedModCount = this.this$0.modCount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
class EntrySet extends AbstractSet<Map.Entry<K, V>> {
|
||
|
|
final LinkedTreeMap this$0;
|
||
|
|
|
||
|
|
EntrySet(LinkedTreeMap linkedTreeMap) {
|
||
|
|
this.this$0 = linkedTreeMap;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public int size() {
|
||
|
|
return this.this$0.size;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
|
||
|
|
public Iterator<Map.Entry<K, V>> iterator() {
|
||
|
|
return new LinkedTreeMapIterator(this) { // from class: com.google.gson.internal.LinkedTreeMap.EntrySet.1
|
||
|
|
final EntrySet this$1;
|
||
|
|
|
||
|
|
{
|
||
|
|
this.this$1 = this;
|
||
|
|
LinkedTreeMap linkedTreeMap = this.this$0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Iterator
|
||
|
|
public Map.Entry<K, V> next() {
|
||
|
|
return nextNode();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public boolean contains(Object obj) {
|
||
|
|
return (obj instanceof Map.Entry) && this.this$0.findByEntry((Map.Entry) obj) != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public boolean remove(Object obj) {
|
||
|
|
Node<K, V> findByEntry;
|
||
|
|
if (!(obj instanceof Map.Entry) || (findByEntry = this.this$0.findByEntry((Map.Entry) obj)) == null) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
this.this$0.removeInternal(findByEntry, true);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public void clear() {
|
||
|
|
this.this$0.clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
final class KeySet extends AbstractSet<K> {
|
||
|
|
final LinkedTreeMap this$0;
|
||
|
|
|
||
|
|
KeySet(LinkedTreeMap linkedTreeMap) {
|
||
|
|
this.this$0 = linkedTreeMap;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public final int size() {
|
||
|
|
return this.this$0.size;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
|
||
|
|
public final Iterator<K> iterator() {
|
||
|
|
return new LinkedTreeMapIterator(this) { // from class: com.google.gson.internal.LinkedTreeMap.KeySet.1
|
||
|
|
final KeySet this$1;
|
||
|
|
|
||
|
|
{
|
||
|
|
this.this$1 = this;
|
||
|
|
LinkedTreeMap linkedTreeMap = this.this$0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.Iterator
|
||
|
|
public K next() {
|
||
|
|
return nextNode().key;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public final boolean contains(Object obj) {
|
||
|
|
return this.this$0.containsKey(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public final boolean remove(Object obj) {
|
||
|
|
return this.this$0.removeInternalByKey(obj) != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||
|
|
public final void clear() {
|
||
|
|
this.this$0.clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Object writeReplace() throws ObjectStreamException {
|
||
|
|
return new LinkedHashMap(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void readObject(ObjectInputStream objectInputStream) throws IOException {
|
||
|
|
throw new InvalidObjectException("Deserialization is unsupported");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.util.AbstractMap, java.util.Map
|
||
|
|
public final int size() {
|
||
|
|
return this.size;
|
||
|
|
}
|
||
|
|
}
|