568 lines
19 KiB
Java
568 lines
19 KiB
Java
package androidx.collection;
|
|
|
|
import androidx.annotation.Nullable;
|
|
import java.lang.reflect.Array;
|
|
import java.util.Collection;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.Set;
|
|
public abstract class MapCollections<K, V> {
|
|
@Nullable
|
|
public MapCollections<K, V>.EntrySet mEntrySet;
|
|
@Nullable
|
|
public MapCollections<K, V>.KeySet mKeySet;
|
|
@Nullable
|
|
public MapCollections<K, V>.ValuesCollection mValues;
|
|
|
|
public final class ArrayIterator<T> implements Iterator<T> {
|
|
public boolean mCanRemove = false;
|
|
public int mIndex;
|
|
public final int mOffset;
|
|
public int mSize;
|
|
|
|
public ArrayIterator(int i) {
|
|
this.mOffset = i;
|
|
this.mSize = MapCollections.this.colGetSize();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public boolean hasNext() {
|
|
return this.mIndex < this.mSize;
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public T next() {
|
|
if (hasNext()) {
|
|
T t = (T) MapCollections.this.colGetEntry(this.mIndex, this.mOffset);
|
|
this.mIndex++;
|
|
this.mCanRemove = true;
|
|
return t;
|
|
}
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public void remove() {
|
|
if (this.mCanRemove) {
|
|
int i = this.mIndex - 1;
|
|
this.mIndex = i;
|
|
this.mSize--;
|
|
this.mCanRemove = false;
|
|
MapCollections.this.colRemoveAt(i);
|
|
return;
|
|
}
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
|
|
public final class EntrySet implements Set<Map.Entry<K, V>> {
|
|
public EntrySet() {
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public /* bridge */ /* synthetic */ boolean add(Object obj) {
|
|
return add((Map.Entry) ((Map.Entry) obj));
|
|
}
|
|
|
|
public boolean add(Map.Entry<K, V> entry) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: androidx.collection.MapCollections */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean addAll(Collection<? extends Map.Entry<K, V>> collection) {
|
|
int colGetSize = MapCollections.this.colGetSize();
|
|
Iterator<? extends Map.Entry<K, V>> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) it.next();
|
|
MapCollections.this.colPut(entry.getKey(), entry.getValue());
|
|
}
|
|
return colGetSize != MapCollections.this.colGetSize();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public void clear() {
|
|
MapCollections.this.colClear();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean contains(Object obj) {
|
|
if (!(obj instanceof Map.Entry)) {
|
|
return false;
|
|
}
|
|
Map.Entry entry = (Map.Entry) obj;
|
|
int colIndexOfKey = MapCollections.this.colIndexOfKey(entry.getKey());
|
|
if (colIndexOfKey < 0) {
|
|
return false;
|
|
}
|
|
return ContainerHelpers.equal(MapCollections.this.colGetEntry(colIndexOfKey, 1), entry.getValue());
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean containsAll(Collection<?> collection) {
|
|
Iterator<?> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
if (!contains(it.next())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Object
|
|
public boolean equals(Object obj) {
|
|
return MapCollections.equalsSetHelper(this, obj);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Object
|
|
public int hashCode() {
|
|
int i = 0;
|
|
for (int colGetSize = MapCollections.this.colGetSize() - 1; colGetSize >= 0; colGetSize--) {
|
|
Object colGetEntry = MapCollections.this.colGetEntry(colGetSize, 0);
|
|
Object colGetEntry2 = MapCollections.this.colGetEntry(colGetSize, 1);
|
|
i += (colGetEntry == null ? 0 : colGetEntry.hashCode()) ^ (colGetEntry2 == null ? 0 : colGetEntry2.hashCode());
|
|
}
|
|
return i;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean isEmpty() {
|
|
return MapCollections.this.colGetSize() == 0;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Iterable
|
|
public Iterator<Map.Entry<K, V>> iterator() {
|
|
return new MapIterator();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean remove(Object obj) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean removeAll(Collection<?> collection) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean retainAll(Collection<?> collection) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public int size() {
|
|
return MapCollections.this.colGetSize();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public Object[] toArray() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public <T> T[] toArray(T[] tArr) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
public final class KeySet implements Set<K> {
|
|
public KeySet() {
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean add(K k) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean addAll(Collection<? extends K> collection) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public void clear() {
|
|
MapCollections.this.colClear();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean contains(Object obj) {
|
|
return MapCollections.this.colIndexOfKey(obj) >= 0;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean containsAll(Collection<?> collection) {
|
|
return MapCollections.containsAllHelper(MapCollections.this.colGetMap(), collection);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Object
|
|
public boolean equals(Object obj) {
|
|
return MapCollections.equalsSetHelper(this, obj);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Object
|
|
public int hashCode() {
|
|
int i = 0;
|
|
for (int colGetSize = MapCollections.this.colGetSize() - 1; colGetSize >= 0; colGetSize--) {
|
|
Object colGetEntry = MapCollections.this.colGetEntry(colGetSize, 0);
|
|
i += colGetEntry == null ? 0 : colGetEntry.hashCode();
|
|
}
|
|
return i;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean isEmpty() {
|
|
return MapCollections.this.colGetSize() == 0;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection, java.lang.Iterable
|
|
public Iterator<K> iterator() {
|
|
return new ArrayIterator(0);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean remove(Object obj) {
|
|
int colIndexOfKey = MapCollections.this.colIndexOfKey(obj);
|
|
if (colIndexOfKey < 0) {
|
|
return false;
|
|
}
|
|
MapCollections.this.colRemoveAt(colIndexOfKey);
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean removeAll(Collection<?> collection) {
|
|
return MapCollections.removeAllHelper(MapCollections.this.colGetMap(), collection);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public boolean retainAll(Collection<?> collection) {
|
|
return MapCollections.retainAllHelper(MapCollections.this.colGetMap(), collection);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public int size() {
|
|
return MapCollections.this.colGetSize();
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public Object[] toArray() {
|
|
return MapCollections.this.toArrayHelper(0);
|
|
}
|
|
|
|
@Override // java.util.Set, java.util.Collection
|
|
public <T> T[] toArray(T[] tArr) {
|
|
return (T[]) MapCollections.this.toArrayHelper(tArr, 0);
|
|
}
|
|
}
|
|
|
|
public final class MapIterator implements Iterator<Map.Entry<K, V>>, Map.Entry<K, V> {
|
|
public int mEnd;
|
|
public boolean mEntryValid = false;
|
|
public int mIndex;
|
|
|
|
public MapIterator() {
|
|
this.mEnd = MapCollections.this.colGetSize() - 1;
|
|
this.mIndex = -1;
|
|
}
|
|
|
|
@Override // java.lang.Object, java.util.Map.Entry
|
|
public boolean equals(Object obj) {
|
|
if (!this.mEntryValid) {
|
|
throw new IllegalStateException("This container does not support retaining Map.Entry objects");
|
|
} else if (!(obj instanceof Map.Entry)) {
|
|
return false;
|
|
} else {
|
|
Map.Entry entry = (Map.Entry) obj;
|
|
return ContainerHelpers.equal(entry.getKey(), MapCollections.this.colGetEntry(this.mIndex, 0)) && ContainerHelpers.equal(entry.getValue(), MapCollections.this.colGetEntry(this.mIndex, 1));
|
|
}
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public K getKey() {
|
|
if (this.mEntryValid) {
|
|
return (K) MapCollections.this.colGetEntry(this.mIndex, 0);
|
|
}
|
|
throw new IllegalStateException("This container does not support retaining Map.Entry objects");
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public V getValue() {
|
|
if (this.mEntryValid) {
|
|
return (V) MapCollections.this.colGetEntry(this.mIndex, 1);
|
|
}
|
|
throw new IllegalStateException("This container does not support retaining Map.Entry objects");
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public boolean hasNext() {
|
|
return this.mIndex < this.mEnd;
|
|
}
|
|
|
|
@Override // java.lang.Object, java.util.Map.Entry
|
|
public int hashCode() {
|
|
if (this.mEntryValid) {
|
|
int i = 0;
|
|
Object colGetEntry = MapCollections.this.colGetEntry(this.mIndex, 0);
|
|
Object colGetEntry2 = MapCollections.this.colGetEntry(this.mIndex, 1);
|
|
int hashCode = colGetEntry == null ? 0 : colGetEntry.hashCode();
|
|
if (colGetEntry2 != null) {
|
|
i = colGetEntry2.hashCode();
|
|
}
|
|
return hashCode ^ i;
|
|
}
|
|
throw new IllegalStateException("This container does not support retaining Map.Entry objects");
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public Map.Entry<K, V> next() {
|
|
if (hasNext()) {
|
|
this.mIndex++;
|
|
this.mEntryValid = true;
|
|
return this;
|
|
}
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
@Override // java.util.Iterator
|
|
public void remove() {
|
|
if (this.mEntryValid) {
|
|
MapCollections.this.colRemoveAt(this.mIndex);
|
|
this.mIndex--;
|
|
this.mEnd--;
|
|
this.mEntryValid = false;
|
|
return;
|
|
}
|
|
throw new IllegalStateException();
|
|
}
|
|
|
|
@Override // java.util.Map.Entry
|
|
public V setValue(V v) {
|
|
if (this.mEntryValid) {
|
|
return (V) MapCollections.this.colSetValue(this.mIndex, v);
|
|
}
|
|
throw new IllegalStateException("This container does not support retaining Map.Entry objects");
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public String toString() {
|
|
return getKey() + "=" + getValue();
|
|
}
|
|
}
|
|
|
|
public final class ValuesCollection implements Collection<V> {
|
|
public ValuesCollection() {
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean add(V v) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean addAll(Collection<? extends V> collection) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public void clear() {
|
|
MapCollections.this.colClear();
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean contains(Object obj) {
|
|
return MapCollections.this.colIndexOfValue(obj) >= 0;
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean containsAll(Collection<?> collection) {
|
|
Iterator<?> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
if (!contains(it.next())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean isEmpty() {
|
|
return MapCollections.this.colGetSize() == 0;
|
|
}
|
|
|
|
@Override // java.util.Collection, java.lang.Iterable
|
|
public Iterator<V> iterator() {
|
|
return new ArrayIterator(1);
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean remove(Object obj) {
|
|
int colIndexOfValue = MapCollections.this.colIndexOfValue(obj);
|
|
if (colIndexOfValue < 0) {
|
|
return false;
|
|
}
|
|
MapCollections.this.colRemoveAt(colIndexOfValue);
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean removeAll(Collection<?> collection) {
|
|
int colGetSize = MapCollections.this.colGetSize();
|
|
int i = 0;
|
|
boolean z2 = false;
|
|
while (i < colGetSize) {
|
|
if (collection.contains(MapCollections.this.colGetEntry(i, 1))) {
|
|
MapCollections.this.colRemoveAt(i);
|
|
i--;
|
|
colGetSize--;
|
|
z2 = true;
|
|
}
|
|
i++;
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public boolean retainAll(Collection<?> collection) {
|
|
int colGetSize = MapCollections.this.colGetSize();
|
|
int i = 0;
|
|
boolean z2 = false;
|
|
while (i < colGetSize) {
|
|
if (!collection.contains(MapCollections.this.colGetEntry(i, 1))) {
|
|
MapCollections.this.colRemoveAt(i);
|
|
i--;
|
|
colGetSize--;
|
|
z2 = true;
|
|
}
|
|
i++;
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public int size() {
|
|
return MapCollections.this.colGetSize();
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public Object[] toArray() {
|
|
return MapCollections.this.toArrayHelper(1);
|
|
}
|
|
|
|
@Override // java.util.Collection
|
|
public <T> T[] toArray(T[] tArr) {
|
|
return (T[]) MapCollections.this.toArrayHelper(tArr, 1);
|
|
}
|
|
}
|
|
|
|
public static <K, V> boolean containsAllHelper(Map<K, V> map, Collection<?> collection) {
|
|
Iterator<?> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
if (!map.containsKey(it.next())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static <T> boolean equalsSetHelper(Set<T> set, Object obj) {
|
|
if (set == obj) {
|
|
return true;
|
|
}
|
|
if (obj instanceof Set) {
|
|
Set set2 = (Set) obj;
|
|
try {
|
|
return set.size() == set2.size() && set.containsAll(set2);
|
|
} catch (ClassCastException | NullPointerException unused) {
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static <K, V> boolean removeAllHelper(Map<K, V> map, Collection<?> collection) {
|
|
int size = map.size();
|
|
Iterator<?> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
map.remove(it.next());
|
|
}
|
|
return size != map.size();
|
|
}
|
|
|
|
public static <K, V> boolean retainAllHelper(Map<K, V> map, Collection<?> collection) {
|
|
int size = map.size();
|
|
Iterator<K> it = map.keySet().iterator();
|
|
while (it.hasNext()) {
|
|
if (!collection.contains(it.next())) {
|
|
it.remove();
|
|
}
|
|
}
|
|
return size != map.size();
|
|
}
|
|
|
|
public abstract void colClear();
|
|
|
|
public abstract Object colGetEntry(int i, int i2);
|
|
|
|
public abstract Map<K, V> colGetMap();
|
|
|
|
public abstract int colGetSize();
|
|
|
|
public abstract int colIndexOfKey(Object obj);
|
|
|
|
public abstract int colIndexOfValue(Object obj);
|
|
|
|
public abstract void colPut(K k, V v);
|
|
|
|
public abstract void colRemoveAt(int i);
|
|
|
|
public abstract V colSetValue(int i, V v);
|
|
|
|
public Set<Map.Entry<K, V>> getEntrySet() {
|
|
if (this.mEntrySet == null) {
|
|
this.mEntrySet = new EntrySet();
|
|
}
|
|
return this.mEntrySet;
|
|
}
|
|
|
|
public Set<K> getKeySet() {
|
|
if (this.mKeySet == null) {
|
|
this.mKeySet = new KeySet();
|
|
}
|
|
return this.mKeySet;
|
|
}
|
|
|
|
public Collection<V> getValues() {
|
|
if (this.mValues == null) {
|
|
this.mValues = new ValuesCollection();
|
|
}
|
|
return this.mValues;
|
|
}
|
|
|
|
public Object[] toArrayHelper(int i) {
|
|
int colGetSize = colGetSize();
|
|
Object[] objArr = new Object[colGetSize];
|
|
for (int i2 = 0; i2 < colGetSize; i2++) {
|
|
objArr[i2] = colGetEntry(i2, i);
|
|
}
|
|
return objArr;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r4v9, resolved type: T[] */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public <T> T[] toArrayHelper(T[] tArr, int i) {
|
|
int colGetSize = colGetSize();
|
|
if (tArr.length < colGetSize) {
|
|
tArr = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), colGetSize));
|
|
}
|
|
for (int i2 = 0; i2 < colGetSize; i2++) {
|
|
tArr[i2] = colGetEntry(i2, i);
|
|
}
|
|
if (tArr.length > colGetSize) {
|
|
tArr[colGetSize] = null;
|
|
}
|
|
return tArr;
|
|
}
|
|
}
|