CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.errorprone.annotations.DoNotMock;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.io.Serializable;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.SortedMap;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
@DoNotMock("Use ImmutableMap.of or another implementation")
public abstract class ImmutableMap<K, V> implements Map<K, V>, Serializable {
static final Map.Entry<?, ?>[] EMPTY_ENTRY_ARRAY = new Map.Entry[0];
@CheckForNull
@LazyInit
private transient ImmutableSet<Map.Entry<K, V>> entrySet;
@CheckForNull
@LazyInit
private transient ImmutableSet<K> keySet;
@CheckForNull
@LazyInit
private transient ImmutableSetMultimap<K, V> multimapView;
@CheckForNull
@LazyInit
private transient ImmutableCollection<V> values;
/* access modifiers changed from: package-private */
public abstract ImmutableSet<Map.Entry<K, V>> createEntrySet();
/* access modifiers changed from: package-private */
public abstract ImmutableSet<K> createKeySet();
/* access modifiers changed from: package-private */
public abstract ImmutableCollection<V> createValues();
@CheckForNull
public abstract V get(@CheckForNull Object obj);
/* access modifiers changed from: package-private */
public boolean isHashCodeFast() {
return false;
}
/* access modifiers changed from: package-private */
public abstract boolean isPartialView();
public static <K, V> ImmutableMap<K, V> of() {
return RegularImmutableMap.EMPTY;
}
public static <K, V> ImmutableMap<K, V> of(K k, V v) {
CollectPreconditions.checkEntryNotNull(k, v);
return RegularImmutableMap.create(1, new Object[]{k, v});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
return RegularImmutableMap.create(2, new Object[]{k, v, k2, v2});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
return RegularImmutableMap.create(3, new Object[]{k, v, k2, v2, k3, v3});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
return RegularImmutableMap.create(4, new Object[]{k, v, k2, v2, k3, v3, k4, v4});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
return RegularImmutableMap.create(5, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
CollectPreconditions.checkEntryNotNull(k6, v6);
return RegularImmutableMap.create(6, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
CollectPreconditions.checkEntryNotNull(k6, v6);
CollectPreconditions.checkEntryNotNull(k7, v7);
return RegularImmutableMap.create(7, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
CollectPreconditions.checkEntryNotNull(k6, v6);
CollectPreconditions.checkEntryNotNull(k7, v7);
CollectPreconditions.checkEntryNotNull(k8, v8);
return RegularImmutableMap.create(8, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
CollectPreconditions.checkEntryNotNull(k6, v6);
CollectPreconditions.checkEntryNotNull(k7, v7);
CollectPreconditions.checkEntryNotNull(k8, v8);
CollectPreconditions.checkEntryNotNull(k9, v9);
return RegularImmutableMap.create(9, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9});
}
public static <K, V> ImmutableMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
CollectPreconditions.checkEntryNotNull(k, v);
CollectPreconditions.checkEntryNotNull(k2, v2);
CollectPreconditions.checkEntryNotNull(k3, v3);
CollectPreconditions.checkEntryNotNull(k4, v4);
CollectPreconditions.checkEntryNotNull(k5, v5);
CollectPreconditions.checkEntryNotNull(k6, v6);
CollectPreconditions.checkEntryNotNull(k7, v7);
CollectPreconditions.checkEntryNotNull(k8, v8);
CollectPreconditions.checkEntryNotNull(k9, v9);
CollectPreconditions.checkEntryNotNull(k10, v10);
return RegularImmutableMap.create(10, new Object[]{k, v, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9, k10, v10});
}
@SafeVarargs
public static <K, V> ImmutableMap<K, V> ofEntries(Map.Entry<? extends K, ? extends V>... entryArr) {
return copyOf(Arrays.asList(entryArr));
}
static <K, V> Map.Entry<K, V> entryOf(K k, V v) {
CollectPreconditions.checkEntryNotNull(k, v);
return new AbstractMap.SimpleImmutableEntry(k, v);
}
public static <K, V> Builder<K, V> builder() {
return new Builder<>();
}
public static <K, V> Builder<K, V> builderWithExpectedSize(int i) {
CollectPreconditions.checkNonnegative(i, "expectedSize");
return new Builder<>(i);
}
static void checkNoConflict(boolean z, String str, Map.Entry<?, ?> entry, Map.Entry<?, ?> entry2) {
if (!z) {
throw conflictException(str, entry, entry2);
}
}
static IllegalArgumentException conflictException(String str, Object obj, Object obj2) {
String valueOf = String.valueOf(obj);
String valueOf2 = String.valueOf(obj2);
StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 34 + String.valueOf(valueOf).length() + String.valueOf(valueOf2).length());
sb.append("Multiple entries with same ");
sb.append(str);
sb.append(": ");
sb.append(valueOf);
sb.append(" and ");
sb.append(valueOf2);
return new IllegalArgumentException(sb.toString());
}
@DoNotMock
public static class Builder<K, V> {
Object[] alternatingKeysAndValues;
boolean entriesUsed;
int size;
@CheckForNull
Comparator<? super V> valueComparator;
public Builder() {
this(4);
}
Builder(int i) {
this.alternatingKeysAndValues = new Object[(i * 2)];
this.size = 0;
this.entriesUsed = false;
}
private void ensureCapacity(int i) {
int i2 = i * 2;
Object[] objArr = this.alternatingKeysAndValues;
if (i2 > objArr.length) {
this.alternatingKeysAndValues = Arrays.copyOf(objArr, ImmutableCollection.Builder.expandedCapacity(objArr.length, i2));
this.entriesUsed = false;
}
}
public Builder<K, V> put(K k, V v) {
ensureCapacity(this.size + 1);
CollectPreconditions.checkEntryNotNull(k, v);
Object[] objArr = this.alternatingKeysAndValues;
int i = this.size;
objArr[i * 2] = k;
objArr[(i * 2) + 1] = v;
this.size = i + 1;
return this;
}
public Builder<K, V> put(Map.Entry<? extends K, ? extends V> entry) {
return put(entry.getKey(), entry.getValue());
}
public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
return putAll(map.entrySet());
}
public Builder<K, V> putAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
if (iterable instanceof Collection) {
ensureCapacity(this.size + ((Collection) iterable).size());
}
for (Map.Entry put : iterable) {
put(put);
}
return this;
}
public Builder<K, V> orderEntriesByValue(Comparator<? super V> comparator) {
Preconditions.checkState(this.valueComparator == null, "valueComparator was already set");
this.valueComparator = (Comparator) Preconditions.checkNotNull(comparator, "valueComparator");
return this;
}
/* access modifiers changed from: package-private */
public Builder<K, V> combine(Builder<K, V> builder) {
Preconditions.checkNotNull(builder);
ensureCapacity(this.size + builder.size);
System.arraycopy(builder.alternatingKeysAndValues, 0, this.alternatingKeysAndValues, this.size * 2, builder.size * 2);
this.size += builder.size;
return this;
}
public ImmutableMap<K, V> build() {
return buildOrThrow();
}
public ImmutableMap<K, V> buildOrThrow() {
sortEntries();
this.entriesUsed = true;
return RegularImmutableMap.create(this.size, this.alternatingKeysAndValues);
}
/* access modifiers changed from: package-private */
public void sortEntries() {
int i;
if (this.valueComparator != null) {
if (this.entriesUsed) {
this.alternatingKeysAndValues = Arrays.copyOf(this.alternatingKeysAndValues, this.size * 2);
}
Map.Entry[] entryArr = new Map.Entry[this.size];
int i2 = 0;
while (true) {
i = this.size;
if (i2 >= i) {
break;
}
int i3 = i2 * 2;
Object obj = this.alternatingKeysAndValues[i3];
Objects.requireNonNull(obj);
Object obj2 = this.alternatingKeysAndValues[i3 + 1];
Objects.requireNonNull(obj2);
entryArr[i2] = new AbstractMap.SimpleImmutableEntry(obj, obj2);
i2++;
}
Arrays.sort(entryArr, 0, i, Ordering.from(this.valueComparator).onResultOf(Maps.valueFunction()));
for (int i4 = 0; i4 < this.size; i4++) {
int i5 = i4 * 2;
this.alternatingKeysAndValues[i5] = entryArr[i4].getKey();
this.alternatingKeysAndValues[i5 + 1] = entryArr[i4].getValue();
}
}
}
}
public static <K, V> ImmutableMap<K, V> copyOf(Map<? extends K, ? extends V> map) {
if ((map instanceof ImmutableMap) && !(map instanceof SortedMap)) {
ImmutableMap<K, V> immutableMap = (ImmutableMap) map;
if (!immutableMap.isPartialView()) {
return immutableMap;
}
}
return copyOf(map.entrySet());
}
public static <K, V> ImmutableMap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
Builder builder = new Builder(iterable instanceof Collection ? ((Collection) iterable).size() : 4);
builder.putAll(iterable);
return builder.build();
}
static abstract class IteratorBasedImmutableMap<K, V> extends ImmutableMap<K, V> {
/* access modifiers changed from: package-private */
public abstract UnmodifiableIterator<Map.Entry<K, V>> entryIterator();
IteratorBasedImmutableMap() {
}
public /* bridge */ /* synthetic */ Set entrySet() {
return ImmutableMap.super.entrySet();
}
public /* bridge */ /* synthetic */ Set keySet() {
return ImmutableMap.super.keySet();
}
public /* bridge */ /* synthetic */ Collection values() {
return ImmutableMap.super.values();
}
/* access modifiers changed from: package-private */
public ImmutableSet<K> createKeySet() {
return new ImmutableMapKeySet(this);
}
/* access modifiers changed from: package-private */
public ImmutableSet<Map.Entry<K, V>> createEntrySet() {
return new ImmutableMapEntrySet<K, V>() {
/* access modifiers changed from: package-private */
public ImmutableMap<K, V> map() {
return IteratorBasedImmutableMap.this;
}
public UnmodifiableIterator<Map.Entry<K, V>> iterator() {
return IteratorBasedImmutableMap.this.entryIterator();
}
};
}
/* access modifiers changed from: package-private */
public ImmutableCollection<V> createValues() {
return new ImmutableMapValues(this);
}
}
ImmutableMap() {
}
@CheckForNull
@Deprecated
public final V put(K k, V v) {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final V remove(@CheckForNull Object obj) {
throw new UnsupportedOperationException();
}
@Deprecated
public final void putAll(Map<? extends K, ? extends V> map) {
throw new UnsupportedOperationException();
}
@Deprecated
public final void clear() {
throw new UnsupportedOperationException();
}
public boolean isEmpty() {
return size() == 0;
}
public boolean containsKey(@CheckForNull Object obj) {
return get(obj) != null;
}
public boolean containsValue(@CheckForNull Object obj) {
return values().contains(obj);
}
@CheckForNull
public final V getOrDefault(@CheckForNull Object obj, @CheckForNull V v) {
V v2 = get(obj);
return v2 != null ? v2 : v;
}
public ImmutableSet<Map.Entry<K, V>> entrySet() {
ImmutableSet<Map.Entry<K, V>> immutableSet = this.entrySet;
if (immutableSet != null) {
return immutableSet;
}
ImmutableSet<Map.Entry<K, V>> createEntrySet = createEntrySet();
this.entrySet = createEntrySet;
return createEntrySet;
}
public ImmutableSet<K> keySet() {
ImmutableSet<K> immutableSet = this.keySet;
if (immutableSet != null) {
return immutableSet;
}
ImmutableSet<K> createKeySet = createKeySet();
this.keySet = createKeySet;
return createKeySet;
}
/* access modifiers changed from: package-private */
public UnmodifiableIterator<K> keyIterator() {
final UnmodifiableIterator it = entrySet().iterator();
return new UnmodifiableIterator<K>(this) {
public boolean hasNext() {
return it.hasNext();
}
public K next() {
return ((Map.Entry) it.next()).getKey();
}
};
}
public ImmutableCollection<V> values() {
ImmutableCollection<V> immutableCollection = this.values;
if (immutableCollection != null) {
return immutableCollection;
}
ImmutableCollection<V> createValues = createValues();
this.values = createValues;
return createValues;
}
public ImmutableSetMultimap<K, V> asMultimap() {
if (isEmpty()) {
return ImmutableSetMultimap.of();
}
ImmutableSetMultimap<K, V> immutableSetMultimap = this.multimapView;
if (immutableSetMultimap != null) {
return immutableSetMultimap;
}
ImmutableSetMultimap<K, V> immutableSetMultimap2 = new ImmutableSetMultimap<>(new MapViewOfValuesAsSingletonSets(), size(), (Comparator) null);
this.multimapView = immutableSetMultimap2;
return immutableSetMultimap2;
}
private final class MapViewOfValuesAsSingletonSets extends IteratorBasedImmutableMap<K, ImmutableSet<V>> {
private MapViewOfValuesAsSingletonSets() {
}
public int size() {
return ImmutableMap.this.size();
}
/* access modifiers changed from: package-private */
public ImmutableSet<K> createKeySet() {
return ImmutableMap.this.keySet();
}
public boolean containsKey(@CheckForNull Object obj) {
return ImmutableMap.this.containsKey(obj);
}
@CheckForNull
public ImmutableSet<V> get(@CheckForNull Object obj) {
Object obj2 = ImmutableMap.this.get(obj);
if (obj2 == null) {
return null;
}
return ImmutableSet.of(obj2);
}
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return ImmutableMap.this.isPartialView();
}
public int hashCode() {
return ImmutableMap.this.hashCode();
}
/* access modifiers changed from: package-private */
public boolean isHashCodeFast() {
return ImmutableMap.this.isHashCodeFast();
}
/* access modifiers changed from: package-private */
public UnmodifiableIterator<Map.Entry<K, ImmutableSet<V>>> entryIterator() {
final UnmodifiableIterator it = ImmutableMap.this.entrySet().iterator();
return new UnmodifiableIterator<Map.Entry<K, ImmutableSet<V>>>(this) {
public boolean hasNext() {
return it.hasNext();
}
public Map.Entry<K, ImmutableSet<V>> next() {
final Map.Entry entry = (Map.Entry) it.next();
return new AbstractMapEntry<K, ImmutableSet<V>>(this) {
public K getKey() {
return entry.getKey();
}
public ImmutableSet<V> getValue() {
return ImmutableSet.of(entry.getValue());
}
};
}
};
}
}
public boolean equals(@CheckForNull Object obj) {
return Maps.equalsImpl(this, obj);
}
public int hashCode() {
return Sets.hashCodeImpl(entrySet());
}
public String toString() {
return Maps.toStringImpl(this);
}
static class SerializedForm<K, V> implements Serializable {
private static final boolean USE_LEGACY_SERIALIZATION = true;
private static final long serialVersionUID = 0;
private final Object keys;
private final Object values;
SerializedForm(ImmutableMap<K, V> immutableMap) {
Object[] objArr = new Object[immutableMap.size()];
Object[] objArr2 = new Object[immutableMap.size()];
UnmodifiableIterator<Map.Entry<K, V>> it = immutableMap.entrySet().iterator();
int i = 0;
while (it.hasNext()) {
Map.Entry next = it.next();
objArr[i] = next.getKey();
objArr2[i] = next.getValue();
i++;
}
this.keys = objArr;
this.values = objArr2;
}
/* access modifiers changed from: package-private */
public final Object readResolve() {
Object obj = this.keys;
if (!(obj instanceof ImmutableSet)) {
return legacyReadResolve();
}
ImmutableSet immutableSet = (ImmutableSet) obj;
Builder makeBuilder = makeBuilder(immutableSet.size());
UnmodifiableIterator it = immutableSet.iterator();
UnmodifiableIterator it2 = ((ImmutableCollection) this.values).iterator();
while (it.hasNext()) {
makeBuilder.put(it.next(), it2.next());
}
return makeBuilder.build();
}
/* access modifiers changed from: package-private */
public final Object legacyReadResolve() {
Object[] objArr = (Object[]) this.keys;
Object[] objArr2 = (Object[]) this.values;
Builder makeBuilder = makeBuilder(objArr.length);
for (int i = 0; i < objArr.length; i++) {
makeBuilder.put(objArr[i], objArr2[i]);
}
return makeBuilder.build();
}
/* access modifiers changed from: package-private */
public Builder<K, V> makeBuilder(int i) {
return new Builder<>(i);
}
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(this);
}
}
Download file