CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.Multimaps;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
abstract class AbstractMultimap<K, V> implements Multimap<K, V> {
@CheckForNull
@LazyInit
private transient Map<K, Collection<V>> asMap;
@CheckForNull
@LazyInit
private transient Collection<Map.Entry<K, V>> entries;
@CheckForNull
@LazyInit
private transient Set<K> keySet;
@CheckForNull
@LazyInit
private transient Multiset<K> keys;
@CheckForNull
@LazyInit
private transient Collection<V> values;
/* access modifiers changed from: package-private */
public abstract Map<K, Collection<V>> createAsMap();
/* access modifiers changed from: package-private */
public abstract Collection<Map.Entry<K, V>> createEntries();
/* access modifiers changed from: package-private */
public abstract Set<K> createKeySet();
/* access modifiers changed from: package-private */
public abstract Multiset<K> createKeys();
/* access modifiers changed from: package-private */
public abstract Collection<V> createValues();
/* access modifiers changed from: package-private */
public abstract Iterator<Map.Entry<K, V>> entryIterator();
AbstractMultimap() {
}
public boolean isEmpty() {
return size() == 0;
}
public boolean containsValue(@CheckForNull Object obj) {
for (Collection contains : asMap().values()) {
if (contains.contains(obj)) {
return true;
}
}
return false;
}
public boolean containsEntry(@CheckForNull Object obj, @CheckForNull Object obj2) {
Collection collection = (Collection) asMap().get(obj);
return collection != null && collection.contains(obj2);
}
public boolean remove(@CheckForNull Object obj, @CheckForNull Object obj2) {
Collection collection = (Collection) asMap().get(obj);
return collection != null && collection.remove(obj2);
}
public boolean put(@ParametricNullness K k, @ParametricNullness V v) {
return get(k).add(v);
}
public boolean putAll(@ParametricNullness K k, Iterable<? extends V> iterable) {
Preconditions.checkNotNull(iterable);
if (iterable instanceof Collection) {
Collection collection = (Collection) iterable;
if (collection.isEmpty() || !get(k).addAll(collection)) {
return false;
}
return true;
}
Iterator<? extends V> it = iterable.iterator();
if (!it.hasNext() || !Iterators.addAll(get(k), it)) {
return false;
}
return true;
}
public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
boolean z = false;
for (Map.Entry next : multimap.entries()) {
z |= put(next.getKey(), next.getValue());
}
return z;
}
public Collection<V> replaceValues(@ParametricNullness K k, Iterable<? extends V> iterable) {
Preconditions.checkNotNull(iterable);
Collection<V> removeAll = removeAll(k);
putAll(k, iterable);
return removeAll;
}
public Collection<Map.Entry<K, V>> entries() {
Collection<Map.Entry<K, V>> collection = this.entries;
if (collection != null) {
return collection;
}
Collection<Map.Entry<K, V>> createEntries = createEntries();
this.entries = createEntries;
return createEntries;
}
class Entries extends Multimaps.Entries<K, V> {
Entries() {
}
/* access modifiers changed from: package-private */
public Multimap<K, V> multimap() {
return AbstractMultimap.this;
}
public Iterator<Map.Entry<K, V>> iterator() {
return AbstractMultimap.this.entryIterator();
}
}
class EntrySet extends AbstractMultimap<K, V>.Entries implements Set<Map.Entry<K, V>> {
EntrySet(AbstractMultimap abstractMultimap) {
super();
}
public int hashCode() {
return Sets.hashCodeImpl(this);
}
public boolean equals(@CheckForNull Object obj) {
return Sets.equalsImpl(this, obj);
}
}
public Set<K> keySet() {
Set<K> set = this.keySet;
if (set != null) {
return set;
}
Set<K> createKeySet = createKeySet();
this.keySet = createKeySet;
return createKeySet;
}
public Multiset<K> keys() {
Multiset<K> multiset = this.keys;
if (multiset != null) {
return multiset;
}
Multiset<K> createKeys = createKeys();
this.keys = createKeys;
return createKeys;
}
public Collection<V> values() {
Collection<V> collection = this.values;
if (collection != null) {
return collection;
}
Collection<V> createValues = createValues();
this.values = createValues;
return createValues;
}
class Values extends AbstractCollection<V> {
Values() {
}
public Iterator<V> iterator() {
return AbstractMultimap.this.valueIterator();
}
public int size() {
return AbstractMultimap.this.size();
}
public boolean contains(@CheckForNull Object obj) {
return AbstractMultimap.this.containsValue(obj);
}
public void clear() {
AbstractMultimap.this.clear();
}
}
/* access modifiers changed from: package-private */
public Iterator<V> valueIterator() {
return Maps.valueIterator(entries().iterator());
}
public Map<K, Collection<V>> asMap() {
Map<K, Collection<V>> map = this.asMap;
if (map != null) {
return map;
}
Map<K, Collection<V>> createAsMap = createAsMap();
this.asMap = createAsMap;
return createAsMap;
}
public boolean equals(@CheckForNull Object obj) {
return Multimaps.equalsImpl(this, obj);
}
public int hashCode() {
return asMap().hashCode();
}
public String toString() {
return asMap().toString();
}
}
Download file