CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Serialization;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Map;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public class ImmutableSetMultimap<K, V> extends ImmutableMultimap<K, V> implements SetMultimap<K, V> {
private static final long serialVersionUID = 0;
private final transient ImmutableSet<V> emptySet;
@CheckForNull
@LazyInit
private transient ImmutableSet<Map.Entry<K, V>> entries;
@CheckForNull
@LazyInit
private transient ImmutableSetMultimap<V, K> inverse;
public static <K, V> ImmutableSetMultimap<K, V> of() {
return EmptyImmutableSetMultimap.INSTANCE;
}
public static <K, V> ImmutableSetMultimap<K, V> of(K k, V v) {
Builder builder = builder();
builder.put((Object) k, (Object) v);
return builder.build();
}
public static <K, V> ImmutableSetMultimap<K, V> of(K k, V v, K k2, V v2) {
Builder builder = builder();
builder.put((Object) k, (Object) v);
builder.put((Object) k2, (Object) v2);
return builder.build();
}
public static <K, V> ImmutableSetMultimap<K, V> of(K k, V v, K k2, V v2, K k3, V v3) {
Builder builder = builder();
builder.put((Object) k, (Object) v);
builder.put((Object) k2, (Object) v2);
builder.put((Object) k3, (Object) v3);
return builder.build();
}
public static <K, V> ImmutableSetMultimap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4) {
Builder builder = builder();
builder.put((Object) k, (Object) v);
builder.put((Object) k2, (Object) v2);
builder.put((Object) k3, (Object) v3);
builder.put((Object) k4, (Object) v4);
return builder.build();
}
public static <K, V> ImmutableSetMultimap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
Builder builder = builder();
builder.put((Object) k, (Object) v);
builder.put((Object) k2, (Object) v2);
builder.put((Object) k3, (Object) v3);
builder.put((Object) k4, (Object) v4);
builder.put((Object) k5, (Object) v5);
return builder.build();
}
public static <K, V> Builder<K, V> builder() {
return new Builder<>();
}
public static final class Builder<K, V> extends ImmutableMultimap.Builder<K, V> {
/* access modifiers changed from: package-private */
public Collection<V> newMutableValueCollection() {
return Platform.preservesInsertionOrderOnAddsSet();
}
public Builder<K, V> put(K k, V v) {
super.put(k, v);
return this;
}
public Builder<K, V> put(Map.Entry<? extends K, ? extends V> entry) {
super.put(entry);
return this;
}
public Builder<K, V> putAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
super.putAll(iterable);
return this;
}
public Builder<K, V> putAll(K k, Iterable<? extends V> iterable) {
super.putAll(k, iterable);
return this;
}
public Builder<K, V> putAll(K k, V... vArr) {
return putAll((Object) k, (Iterable) Arrays.asList(vArr));
}
public Builder<K, V> putAll(Multimap<? extends K, ? extends V> multimap) {
for (Map.Entry next : multimap.asMap().entrySet()) {
putAll(next.getKey(), (Iterable) next.getValue());
}
return this;
}
/* access modifiers changed from: package-private */
public Builder<K, V> combine(ImmutableMultimap.Builder<K, V> builder) {
super.combine(builder);
return this;
}
public Builder<K, V> orderKeysBy(Comparator<? super K> comparator) {
super.orderKeysBy(comparator);
return this;
}
public Builder<K, V> orderValuesBy(Comparator<? super V> comparator) {
super.orderValuesBy(comparator);
return this;
}
public ImmutableSetMultimap<K, V> build() {
Collection entrySet = this.builderMap.entrySet();
if (this.keyComparator != null) {
entrySet = Ordering.from(this.keyComparator).onKeys().immutableSortedCopy(entrySet);
}
return ImmutableSetMultimap.fromMapEntries(entrySet, this.valueComparator);
}
}
public static <K, V> ImmutableSetMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> multimap) {
return copyOf(multimap, (Comparator) null);
}
private static <K, V> ImmutableSetMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> multimap, @CheckForNull Comparator<? super V> comparator) {
Preconditions.checkNotNull(multimap);
if (multimap.isEmpty() && comparator == null) {
return of();
}
if (multimap instanceof ImmutableSetMultimap) {
ImmutableSetMultimap<K, V> immutableSetMultimap = (ImmutableSetMultimap) multimap;
if (!immutableSetMultimap.isPartialView()) {
return immutableSetMultimap;
}
}
return fromMapEntries(multimap.asMap().entrySet(), comparator);
}
public static <K, V> ImmutableSetMultimap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
return new Builder().putAll((Iterable) iterable).build();
}
static <K, V> ImmutableSetMultimap<K, V> fromMapEntries(Collection<? extends Map.Entry<? extends K, ? extends Collection<? extends V>>> collection, @CheckForNull Comparator<? super V> comparator) {
if (collection.isEmpty()) {
return of();
}
ImmutableMap.Builder builder = new ImmutableMap.Builder(collection.size());
int i = 0;
for (Map.Entry entry : collection) {
Object key = entry.getKey();
ImmutableSet<V> valueSet = valueSet(comparator, (Collection) entry.getValue());
if (!valueSet.isEmpty()) {
builder.put(key, valueSet);
i += valueSet.size();
}
}
return new ImmutableSetMultimap<>(builder.build(), i, comparator);
}
ImmutableSetMultimap(ImmutableMap<K, ImmutableSet<V>> immutableMap, int i, @CheckForNull Comparator<? super V> comparator) {
super(immutableMap, i);
this.emptySet = emptySet(comparator);
}
public ImmutableSet<V> get(K k) {
return (ImmutableSet) MoreObjects.firstNonNull((ImmutableSet) this.map.get(k), this.emptySet);
}
public ImmutableSetMultimap<V, K> inverse() {
ImmutableSetMultimap<V, K> immutableSetMultimap = this.inverse;
if (immutableSetMultimap != null) {
return immutableSetMultimap;
}
ImmutableSetMultimap<V, K> invert = invert();
this.inverse = invert;
return invert;
}
private ImmutableSetMultimap<V, K> invert() {
Builder builder = builder();
UnmodifiableIterator it = entries().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
builder.put(entry.getValue(), entry.getKey());
}
ImmutableSetMultimap<V, K> build = builder.build();
build.inverse = this;
return build;
}
@Deprecated
public final ImmutableSet<V> removeAll(@CheckForNull Object obj) {
throw new UnsupportedOperationException();
}
@Deprecated
public final ImmutableSet<V> replaceValues(K k, Iterable<? extends V> iterable) {
throw new UnsupportedOperationException();
}
public ImmutableSet<Map.Entry<K, V>> entries() {
ImmutableSet<Map.Entry<K, V>> immutableSet = this.entries;
if (immutableSet != null) {
return immutableSet;
}
EntrySet entrySet = new EntrySet(this);
this.entries = entrySet;
return entrySet;
}
private static final class EntrySet<K, V> extends ImmutableSet<Map.Entry<K, V>> {
private final transient ImmutableSetMultimap<K, V> multimap;
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return false;
}
EntrySet(ImmutableSetMultimap<K, V> immutableSetMultimap) {
this.multimap = immutableSetMultimap;
}
public boolean contains(@CheckForNull Object obj) {
if (!(obj instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) obj;
return this.multimap.containsEntry(entry.getKey(), entry.getValue());
}
public int size() {
return this.multimap.size();
}
public UnmodifiableIterator<Map.Entry<K, V>> iterator() {
return this.multimap.entryIterator();
}
}
private static <V> ImmutableSet<V> valueSet(@CheckForNull Comparator<? super V> comparator, Collection<? extends V> collection) {
if (comparator == null) {
return ImmutableSet.copyOf(collection);
}
return ImmutableSortedSet.copyOf(comparator, collection);
}
private static <V> ImmutableSet<V> emptySet(@CheckForNull Comparator<? super V> comparator) {
if (comparator == null) {
return ImmutableSet.of();
}
return ImmutableSortedSet.emptySet(comparator);
}
private static <V> ImmutableSet.Builder<V> valuesBuilder(@CheckForNull Comparator<? super V> comparator) {
if (comparator == null) {
return new ImmutableSet.Builder<>();
}
return new ImmutableSortedSet.Builder(comparator);
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.defaultWriteObject();
objectOutputStream.writeObject(valueComparator());
Serialization.writeMultimap(this, objectOutputStream);
}
/* access modifiers changed from: package-private */
@CheckForNull
public Comparator<? super V> valueComparator() {
ImmutableSet<V> immutableSet = this.emptySet;
if (immutableSet instanceof ImmutableSortedSet) {
return ((ImmutableSortedSet) immutableSet).comparator();
}
return null;
}
private static final class SetFieldSettersHolder {
static final Serialization.FieldSetter<ImmutableSetMultimap> EMPTY_SET_FIELD_SETTER = Serialization.getFieldSetter(ImmutableSetMultimap.class, "emptySet");
private SetFieldSettersHolder() {
}
}
private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
objectInputStream.defaultReadObject();
Comparator comparator = (Comparator) objectInputStream.readObject();
int readInt = objectInputStream.readInt();
if (readInt >= 0) {
ImmutableMap.Builder builder = ImmutableMap.builder();
int i = 0;
int i2 = 0;
while (i < readInt) {
Object readObject = objectInputStream.readObject();
int readInt2 = objectInputStream.readInt();
if (readInt2 > 0) {
ImmutableSet.Builder valuesBuilder = valuesBuilder(comparator);
for (int i3 = 0; i3 < readInt2; i3++) {
valuesBuilder.add(objectInputStream.readObject());
}
ImmutableSet build = valuesBuilder.build();
if (build.size() == readInt2) {
builder.put(readObject, build);
i2 += readInt2;
i++;
} else {
String valueOf = String.valueOf(readObject);
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 40);
sb.append("Duplicate key-value pairs exist for key ");
sb.append(valueOf);
throw new InvalidObjectException(sb.toString());
}
} else {
StringBuilder sb2 = new StringBuilder(31);
sb2.append("Invalid value count ");
sb2.append(readInt2);
throw new InvalidObjectException(sb2.toString());
}
}
try {
ImmutableMultimap.FieldSettersHolder.MAP_FIELD_SETTER.set(this, (Object) builder.build());
ImmutableMultimap.FieldSettersHolder.SIZE_FIELD_SETTER.set(this, i2);
SetFieldSettersHolder.EMPTY_SET_FIELD_SETTER.set(this, (Object) emptySet(comparator));
} catch (IllegalArgumentException e) {
throw ((InvalidObjectException) new InvalidObjectException(e.getMessage()).initCause(e));
}
} else {
StringBuilder sb3 = new StringBuilder(29);
sb3.append("Invalid key count ");
sb3.append(readInt);
throw new InvalidObjectException(sb3.toString());
}
}
}
Download file