CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Equivalence;
import com.google.common.base.Preconditions;
import com.google.common.collect.MapMaker;
import com.google.common.collect.MapMakerInternalMap.InternalEntry;
import com.google.common.collect.MapMakerInternalMap.Segment;
import com.google.common.primitives.Ints;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.locks.ReentrantLock;
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
class MapMakerInternalMap<K, V, E extends InternalEntry<K, V, E>, S extends Segment<K, V, E, S>> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable {
static final long CLEANUP_EXECUTOR_DELAY_SECS = 60;
static final int CONTAINS_VALUE_RETRIES = 3;
static final int DRAIN_MAX = 16;
static final int DRAIN_THRESHOLD = 63;
static final int MAXIMUM_CAPACITY = 1073741824;
static final int MAX_SEGMENTS = 65536;
static final WeakValueReference<Object, Object, DummyInternalEntry> UNSET_WEAK_VALUE_REFERENCE = new WeakValueReference<Object, Object, DummyInternalEntry>() {
public void clear() {
}
public WeakValueReference<Object, Object, DummyInternalEntry> copyFor(ReferenceQueue<Object> referenceQueue, DummyInternalEntry dummyInternalEntry) {
return this;
}
public Object get() {
return null;
}
public DummyInternalEntry getEntry() {
return null;
}
};
private static final long serialVersionUID = 5;
final int concurrencyLevel;
final transient InternalEntryHelper<K, V, E, S> entryHelper;
@NullableDecl
transient Set<Map.Entry<K, V>> entrySet;
final Equivalence<Object> keyEquivalence;
@NullableDecl
transient Set<K> keySet;
final transient int segmentMask;
final transient int segmentShift;
final transient Segment<K, V, E, S>[] segments;
@NullableDecl
transient Collection<V> values;
interface InternalEntry<K, V, E extends InternalEntry<K, V, E>> {
int getHash();
K getKey();
E getNext();
V getValue();
}
interface InternalEntryHelper<K, V, E extends InternalEntry<K, V, E>, S extends Segment<K, V, E, S>> {
E copy(S s, E e, @NullableDecl E e2);
Strength keyStrength();
E newEntry(S s, K k, int i, @NullableDecl E e);
S newSegment(MapMakerInternalMap<K, V, E, S> mapMakerInternalMap, int i, int i2);
void setValue(S s, E e, V v);
Strength valueStrength();
}
enum Strength {
STRONG {
/* access modifiers changed from: package-private */
public Equivalence<Object> defaultEquivalence() {
return Equivalence.equals();
}
},
WEAK {
/* access modifiers changed from: package-private */
public Equivalence<Object> defaultEquivalence() {
return Equivalence.identity();
}
};
/* access modifiers changed from: package-private */
public abstract Equivalence<Object> defaultEquivalence();
}
interface StrongValueEntry<K, V, E extends InternalEntry<K, V, E>> extends InternalEntry<K, V, E> {
}
interface WeakValueEntry<K, V, E extends InternalEntry<K, V, E>> extends InternalEntry<K, V, E> {
void clearValue();
WeakValueReference<K, V, E> getValueReference();
}
interface WeakValueReference<K, V, E extends InternalEntry<K, V, E>> {
void clear();
WeakValueReference<K, V, E> copyFor(ReferenceQueue<V> referenceQueue, E e);
@NullableDecl
V get();
E getEntry();
}
static int rehash(int i) {
int i2 = i + ((i << 15) ^ -12931);
int i3 = i2 ^ (i2 >>> 10);
int i4 = i3 + (i3 << 3);
int i5 = i4 ^ (i4 >>> 6);
int i6 = i5 + (i5 << 2) + (i5 << 14);
return i6 ^ (i6 >>> 16);
}
private MapMakerInternalMap(MapMaker mapMaker, InternalEntryHelper<K, V, E, S> internalEntryHelper) {
this.concurrencyLevel = Math.min(mapMaker.getConcurrencyLevel(), 65536);
this.keyEquivalence = mapMaker.getKeyEquivalence();
this.entryHelper = internalEntryHelper;
int min = Math.min(mapMaker.getInitialCapacity(), 1073741824);
int i = 0;
int i2 = 1;
int i3 = 1;
int i4 = 0;
while (i3 < this.concurrencyLevel) {
i4++;
i3 <<= 1;
}
this.segmentShift = 32 - i4;
this.segmentMask = i3 - 1;
this.segments = newSegmentArray(i3);
int i5 = min / i3;
while (i2 < (i3 * i5 < min ? i5 + 1 : i5)) {
i2 <<= 1;
}
while (true) {
Segment<K, V, E, S>[] segmentArr = this.segments;
if (i < segmentArr.length) {
segmentArr[i] = createSegment(i2, -1);
i++;
} else {
return;
}
}
}
static <K, V> MapMakerInternalMap<K, V, ? extends InternalEntry<K, V, ?>, ?> create(MapMaker mapMaker) {
if (mapMaker.getKeyStrength() == Strength.STRONG && mapMaker.getValueStrength() == Strength.STRONG) {
return new MapMakerInternalMap<>(mapMaker, StrongKeyStrongValueEntry.Helper.instance());
}
if (mapMaker.getKeyStrength() == Strength.STRONG && mapMaker.getValueStrength() == Strength.WEAK) {
return new MapMakerInternalMap<>(mapMaker, StrongKeyWeakValueEntry.Helper.instance());
}
if (mapMaker.getKeyStrength() == Strength.WEAK && mapMaker.getValueStrength() == Strength.STRONG) {
return new MapMakerInternalMap<>(mapMaker, WeakKeyStrongValueEntry.Helper.instance());
}
if (mapMaker.getKeyStrength() == Strength.WEAK && mapMaker.getValueStrength() == Strength.WEAK) {
return new MapMakerInternalMap<>(mapMaker, WeakKeyWeakValueEntry.Helper.instance());
}
throw new AssertionError();
}
static <K> MapMakerInternalMap<K, MapMaker.Dummy, ? extends InternalEntry<K, MapMaker.Dummy, ?>, ?> createWithDummyValues(MapMaker mapMaker) {
if (mapMaker.getKeyStrength() == Strength.STRONG && mapMaker.getValueStrength() == Strength.STRONG) {
return new MapMakerInternalMap<>(mapMaker, StrongKeyDummyValueEntry.Helper.instance());
}
if (mapMaker.getKeyStrength() == Strength.WEAK && mapMaker.getValueStrength() == Strength.STRONG) {
return new MapMakerInternalMap<>(mapMaker, WeakKeyDummyValueEntry.Helper.instance());
}
if (mapMaker.getValueStrength() == Strength.WEAK) {
throw new IllegalArgumentException("Map cannot have both weak and dummy values");
}
throw new AssertionError();
}
static abstract class AbstractStrongKeyEntry<K, V, E extends InternalEntry<K, V, E>> implements InternalEntry<K, V, E> {
final int hash;
final K key;
@NullableDecl
final E next;
AbstractStrongKeyEntry(K k, int i, @NullableDecl E e) {
this.key = k;
this.hash = i;
this.next = e;
}
public K getKey() {
return this.key;
}
public int getHash() {
return this.hash;
}
public E getNext() {
return this.next;
}
}
static <K, V, E extends InternalEntry<K, V, E>> WeakValueReference<K, V, E> unsetWeakValueReference() {
return UNSET_WEAK_VALUE_REFERENCE;
}
static final class StrongKeyStrongValueEntry<K, V> extends AbstractStrongKeyEntry<K, V, StrongKeyStrongValueEntry<K, V>> implements StrongValueEntry<K, V, StrongKeyStrongValueEntry<K, V>> {
@NullableDecl
private volatile V value = null;
StrongKeyStrongValueEntry(K k, int i, @NullableDecl StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry) {
super(k, i, strongKeyStrongValueEntry);
}
@NullableDecl
public V getValue() {
return this.value;
}
/* access modifiers changed from: package-private */
public void setValue(V v) {
this.value = v;
}
/* access modifiers changed from: package-private */
public StrongKeyStrongValueEntry<K, V> copy(StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry) {
StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry2 = new StrongKeyStrongValueEntry<>(this.key, this.hash, strongKeyStrongValueEntry);
strongKeyStrongValueEntry2.value = this.value;
return strongKeyStrongValueEntry2;
}
static final class Helper<K, V> implements InternalEntryHelper<K, V, StrongKeyStrongValueEntry<K, V>, StrongKeyStrongValueSegment<K, V>> {
private static final Helper<?, ?> INSTANCE = new Helper<>();
Helper() {
}
static <K, V> Helper<K, V> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.STRONG;
}
public Strength valueStrength() {
return Strength.STRONG;
}
public StrongKeyStrongValueSegment<K, V> newSegment(MapMakerInternalMap<K, V, StrongKeyStrongValueEntry<K, V>, StrongKeyStrongValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
return new StrongKeyStrongValueSegment<>(mapMakerInternalMap, i, i2);
}
public StrongKeyStrongValueEntry<K, V> copy(StrongKeyStrongValueSegment<K, V> strongKeyStrongValueSegment, StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry, @NullableDecl StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry2) {
return strongKeyStrongValueEntry.copy(strongKeyStrongValueEntry2);
}
public void setValue(StrongKeyStrongValueSegment<K, V> strongKeyStrongValueSegment, StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry, V v) {
strongKeyStrongValueEntry.setValue(v);
}
public StrongKeyStrongValueEntry<K, V> newEntry(StrongKeyStrongValueSegment<K, V> strongKeyStrongValueSegment, K k, int i, @NullableDecl StrongKeyStrongValueEntry<K, V> strongKeyStrongValueEntry) {
return new StrongKeyStrongValueEntry<>(k, i, strongKeyStrongValueEntry);
}
}
}
static final class StrongKeyWeakValueEntry<K, V> extends AbstractStrongKeyEntry<K, V, StrongKeyWeakValueEntry<K, V>> implements WeakValueEntry<K, V, StrongKeyWeakValueEntry<K, V>> {
/* access modifiers changed from: private */
public volatile WeakValueReference<K, V, StrongKeyWeakValueEntry<K, V>> valueReference = MapMakerInternalMap.unsetWeakValueReference();
StrongKeyWeakValueEntry(K k, int i, @NullableDecl StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry) {
super(k, i, strongKeyWeakValueEntry);
}
public V getValue() {
return this.valueReference.get();
}
public void clearValue() {
this.valueReference.clear();
}
/* access modifiers changed from: package-private */
public void setValue(V v, ReferenceQueue<V> referenceQueue) {
WeakValueReference<K, V, StrongKeyWeakValueEntry<K, V>> weakValueReference = this.valueReference;
this.valueReference = new WeakValueReferenceImpl(referenceQueue, v, this);
weakValueReference.clear();
}
/* access modifiers changed from: package-private */
public StrongKeyWeakValueEntry<K, V> copy(ReferenceQueue<V> referenceQueue, StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry) {
StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry2 = new StrongKeyWeakValueEntry<>(this.key, this.hash, strongKeyWeakValueEntry);
strongKeyWeakValueEntry2.valueReference = this.valueReference.copyFor(referenceQueue, strongKeyWeakValueEntry2);
return strongKeyWeakValueEntry2;
}
public WeakValueReference<K, V, StrongKeyWeakValueEntry<K, V>> getValueReference() {
return this.valueReference;
}
static final class Helper<K, V> implements InternalEntryHelper<K, V, StrongKeyWeakValueEntry<K, V>, StrongKeyWeakValueSegment<K, V>> {
private static final Helper<?, ?> INSTANCE = new Helper<>();
Helper() {
}
static <K, V> Helper<K, V> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.STRONG;
}
public Strength valueStrength() {
return Strength.WEAK;
}
public StrongKeyWeakValueSegment<K, V> newSegment(MapMakerInternalMap<K, V, StrongKeyWeakValueEntry<K, V>, StrongKeyWeakValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
return new StrongKeyWeakValueSegment<>(mapMakerInternalMap, i, i2);
}
public StrongKeyWeakValueEntry<K, V> copy(StrongKeyWeakValueSegment<K, V> strongKeyWeakValueSegment, StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry, @NullableDecl StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry2) {
if (Segment.isCollected(strongKeyWeakValueEntry)) {
return null;
}
return strongKeyWeakValueEntry.copy(strongKeyWeakValueSegment.queueForValues, strongKeyWeakValueEntry2);
}
public void setValue(StrongKeyWeakValueSegment<K, V> strongKeyWeakValueSegment, StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry, V v) {
strongKeyWeakValueEntry.setValue(v, strongKeyWeakValueSegment.queueForValues);
}
public StrongKeyWeakValueEntry<K, V> newEntry(StrongKeyWeakValueSegment<K, V> strongKeyWeakValueSegment, K k, int i, @NullableDecl StrongKeyWeakValueEntry<K, V> strongKeyWeakValueEntry) {
return new StrongKeyWeakValueEntry<>(k, i, strongKeyWeakValueEntry);
}
}
}
static final class StrongKeyDummyValueEntry<K> extends AbstractStrongKeyEntry<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>> implements StrongValueEntry<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>> {
/* access modifiers changed from: package-private */
public void setValue(MapMaker.Dummy dummy) {
}
StrongKeyDummyValueEntry(K k, int i, @NullableDecl StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry) {
super(k, i, strongKeyDummyValueEntry);
}
public MapMaker.Dummy getValue() {
return MapMaker.Dummy.VALUE;
}
/* access modifiers changed from: package-private */
public StrongKeyDummyValueEntry<K> copy(StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry) {
return new StrongKeyDummyValueEntry<>(this.key, this.hash, strongKeyDummyValueEntry);
}
static final class Helper<K> implements InternalEntryHelper<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>, StrongKeyDummyValueSegment<K>> {
private static final Helper<?> INSTANCE = new Helper<>();
public void setValue(StrongKeyDummyValueSegment<K> strongKeyDummyValueSegment, StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry, MapMaker.Dummy dummy) {
}
Helper() {
}
static <K> Helper<K> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.STRONG;
}
public Strength valueStrength() {
return Strength.STRONG;
}
public StrongKeyDummyValueSegment<K> newSegment(MapMakerInternalMap<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>, StrongKeyDummyValueSegment<K>> mapMakerInternalMap, int i, int i2) {
return new StrongKeyDummyValueSegment<>(mapMakerInternalMap, i, i2);
}
public StrongKeyDummyValueEntry<K> copy(StrongKeyDummyValueSegment<K> strongKeyDummyValueSegment, StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry, @NullableDecl StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry2) {
return strongKeyDummyValueEntry.copy(strongKeyDummyValueEntry2);
}
public StrongKeyDummyValueEntry<K> newEntry(StrongKeyDummyValueSegment<K> strongKeyDummyValueSegment, K k, int i, @NullableDecl StrongKeyDummyValueEntry<K> strongKeyDummyValueEntry) {
return new StrongKeyDummyValueEntry<>(k, i, strongKeyDummyValueEntry);
}
}
}
static abstract class AbstractWeakKeyEntry<K, V, E extends InternalEntry<K, V, E>> extends WeakReference<K> implements InternalEntry<K, V, E> {
final int hash;
@NullableDecl
final E next;
AbstractWeakKeyEntry(ReferenceQueue<K> referenceQueue, K k, int i, @NullableDecl E e) {
super(k, referenceQueue);
this.hash = i;
this.next = e;
}
public K getKey() {
return get();
}
public int getHash() {
return this.hash;
}
public E getNext() {
return this.next;
}
}
static final class WeakKeyDummyValueEntry<K> extends AbstractWeakKeyEntry<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>> implements StrongValueEntry<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>> {
/* access modifiers changed from: package-private */
public void setValue(MapMaker.Dummy dummy) {
}
WeakKeyDummyValueEntry(ReferenceQueue<K> referenceQueue, K k, int i, @NullableDecl WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry) {
super(referenceQueue, k, i, weakKeyDummyValueEntry);
}
public MapMaker.Dummy getValue() {
return MapMaker.Dummy.VALUE;
}
/* access modifiers changed from: package-private */
public WeakKeyDummyValueEntry<K> copy(ReferenceQueue<K> referenceQueue, WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry) {
return new WeakKeyDummyValueEntry<>(referenceQueue, getKey(), this.hash, weakKeyDummyValueEntry);
}
static final class Helper<K> implements InternalEntryHelper<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>, WeakKeyDummyValueSegment<K>> {
private static final Helper<?> INSTANCE = new Helper<>();
public void setValue(WeakKeyDummyValueSegment<K> weakKeyDummyValueSegment, WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry, MapMaker.Dummy dummy) {
}
Helper() {
}
static <K> Helper<K> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.WEAK;
}
public Strength valueStrength() {
return Strength.STRONG;
}
public WeakKeyDummyValueSegment<K> newSegment(MapMakerInternalMap<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>, WeakKeyDummyValueSegment<K>> mapMakerInternalMap, int i, int i2) {
return new WeakKeyDummyValueSegment<>(mapMakerInternalMap, i, i2);
}
public WeakKeyDummyValueEntry<K> copy(WeakKeyDummyValueSegment<K> weakKeyDummyValueSegment, WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry, @NullableDecl WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry2) {
if (weakKeyDummyValueEntry.getKey() == null) {
return null;
}
return weakKeyDummyValueEntry.copy(weakKeyDummyValueSegment.queueForKeys, weakKeyDummyValueEntry2);
}
public WeakKeyDummyValueEntry<K> newEntry(WeakKeyDummyValueSegment<K> weakKeyDummyValueSegment, K k, int i, @NullableDecl WeakKeyDummyValueEntry<K> weakKeyDummyValueEntry) {
return new WeakKeyDummyValueEntry<>(weakKeyDummyValueSegment.queueForKeys, k, i, weakKeyDummyValueEntry);
}
}
}
static final class WeakKeyStrongValueEntry<K, V> extends AbstractWeakKeyEntry<K, V, WeakKeyStrongValueEntry<K, V>> implements StrongValueEntry<K, V, WeakKeyStrongValueEntry<K, V>> {
@NullableDecl
private volatile V value = null;
WeakKeyStrongValueEntry(ReferenceQueue<K> referenceQueue, K k, int i, @NullableDecl WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry) {
super(referenceQueue, k, i, weakKeyStrongValueEntry);
}
@NullableDecl
public V getValue() {
return this.value;
}
/* access modifiers changed from: package-private */
public void setValue(V v) {
this.value = v;
}
/* access modifiers changed from: package-private */
public WeakKeyStrongValueEntry<K, V> copy(ReferenceQueue<K> referenceQueue, WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry) {
WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry2 = new WeakKeyStrongValueEntry<>(referenceQueue, getKey(), this.hash, weakKeyStrongValueEntry);
weakKeyStrongValueEntry2.setValue(this.value);
return weakKeyStrongValueEntry2;
}
static final class Helper<K, V> implements InternalEntryHelper<K, V, WeakKeyStrongValueEntry<K, V>, WeakKeyStrongValueSegment<K, V>> {
private static final Helper<?, ?> INSTANCE = new Helper<>();
Helper() {
}
static <K, V> Helper<K, V> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.WEAK;
}
public Strength valueStrength() {
return Strength.STRONG;
}
public WeakKeyStrongValueSegment<K, V> newSegment(MapMakerInternalMap<K, V, WeakKeyStrongValueEntry<K, V>, WeakKeyStrongValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
return new WeakKeyStrongValueSegment<>(mapMakerInternalMap, i, i2);
}
public WeakKeyStrongValueEntry<K, V> copy(WeakKeyStrongValueSegment<K, V> weakKeyStrongValueSegment, WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry, @NullableDecl WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry2) {
if (weakKeyStrongValueEntry.getKey() == null) {
return null;
}
return weakKeyStrongValueEntry.copy(weakKeyStrongValueSegment.queueForKeys, weakKeyStrongValueEntry2);
}
public void setValue(WeakKeyStrongValueSegment<K, V> weakKeyStrongValueSegment, WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry, V v) {
weakKeyStrongValueEntry.setValue(v);
}
public WeakKeyStrongValueEntry<K, V> newEntry(WeakKeyStrongValueSegment<K, V> weakKeyStrongValueSegment, K k, int i, @NullableDecl WeakKeyStrongValueEntry<K, V> weakKeyStrongValueEntry) {
return new WeakKeyStrongValueEntry<>(weakKeyStrongValueSegment.queueForKeys, k, i, weakKeyStrongValueEntry);
}
}
}
static final class WeakKeyWeakValueEntry<K, V> extends AbstractWeakKeyEntry<K, V, WeakKeyWeakValueEntry<K, V>> implements WeakValueEntry<K, V, WeakKeyWeakValueEntry<K, V>> {
/* access modifiers changed from: private */
public volatile WeakValueReference<K, V, WeakKeyWeakValueEntry<K, V>> valueReference = MapMakerInternalMap.unsetWeakValueReference();
WeakKeyWeakValueEntry(ReferenceQueue<K> referenceQueue, K k, int i, @NullableDecl WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry) {
super(referenceQueue, k, i, weakKeyWeakValueEntry);
}
public V getValue() {
return this.valueReference.get();
}
/* access modifiers changed from: package-private */
public WeakKeyWeakValueEntry<K, V> copy(ReferenceQueue<K> referenceQueue, ReferenceQueue<V> referenceQueue2, WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry) {
WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry2 = new WeakKeyWeakValueEntry<>(referenceQueue, getKey(), this.hash, weakKeyWeakValueEntry);
weakKeyWeakValueEntry2.valueReference = this.valueReference.copyFor(referenceQueue2, weakKeyWeakValueEntry2);
return weakKeyWeakValueEntry2;
}
public void clearValue() {
this.valueReference.clear();
}
/* access modifiers changed from: package-private */
public void setValue(V v, ReferenceQueue<V> referenceQueue) {
WeakValueReference<K, V, WeakKeyWeakValueEntry<K, V>> weakValueReference = this.valueReference;
this.valueReference = new WeakValueReferenceImpl(referenceQueue, v, this);
weakValueReference.clear();
}
public WeakValueReference<K, V, WeakKeyWeakValueEntry<K, V>> getValueReference() {
return this.valueReference;
}
static final class Helper<K, V> implements InternalEntryHelper<K, V, WeakKeyWeakValueEntry<K, V>, WeakKeyWeakValueSegment<K, V>> {
private static final Helper<?, ?> INSTANCE = new Helper<>();
Helper() {
}
static <K, V> Helper<K, V> instance() {
return INSTANCE;
}
public Strength keyStrength() {
return Strength.WEAK;
}
public Strength valueStrength() {
return Strength.WEAK;
}
public WeakKeyWeakValueSegment<K, V> newSegment(MapMakerInternalMap<K, V, WeakKeyWeakValueEntry<K, V>, WeakKeyWeakValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
return new WeakKeyWeakValueSegment<>(mapMakerInternalMap, i, i2);
}
public WeakKeyWeakValueEntry<K, V> copy(WeakKeyWeakValueSegment<K, V> weakKeyWeakValueSegment, WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry, @NullableDecl WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry2) {
if (weakKeyWeakValueEntry.getKey() != null && !Segment.isCollected(weakKeyWeakValueEntry)) {
return weakKeyWeakValueEntry.copy(weakKeyWeakValueSegment.queueForKeys, weakKeyWeakValueSegment.queueForValues, weakKeyWeakValueEntry2);
}
return null;
}
public void setValue(WeakKeyWeakValueSegment<K, V> weakKeyWeakValueSegment, WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry, V v) {
weakKeyWeakValueEntry.setValue(v, weakKeyWeakValueSegment.queueForValues);
}
public WeakKeyWeakValueEntry<K, V> newEntry(WeakKeyWeakValueSegment<K, V> weakKeyWeakValueSegment, K k, int i, @NullableDecl WeakKeyWeakValueEntry<K, V> weakKeyWeakValueEntry) {
return new WeakKeyWeakValueEntry<>(weakKeyWeakValueSegment.queueForKeys, k, i, weakKeyWeakValueEntry);
}
}
}
static final class DummyInternalEntry implements InternalEntry<Object, Object, DummyInternalEntry> {
private DummyInternalEntry() {
throw new AssertionError();
}
public DummyInternalEntry getNext() {
throw new AssertionError();
}
public int getHash() {
throw new AssertionError();
}
public Object getKey() {
throw new AssertionError();
}
public Object getValue() {
throw new AssertionError();
}
}
static final class WeakValueReferenceImpl<K, V, E extends InternalEntry<K, V, E>> extends WeakReference<V> implements WeakValueReference<K, V, E> {
final E entry;
WeakValueReferenceImpl(ReferenceQueue<V> referenceQueue, V v, E e) {
super(v, referenceQueue);
this.entry = e;
}
public E getEntry() {
return this.entry;
}
public WeakValueReference<K, V, E> copyFor(ReferenceQueue<V> referenceQueue, E e) {
return new WeakValueReferenceImpl(referenceQueue, get(), e);
}
}
/* access modifiers changed from: package-private */
public E copyEntry(E e, E e2) {
return segmentFor(e.getHash()).copyEntry(e, e2);
}
/* access modifiers changed from: package-private */
public int hash(Object obj) {
return rehash(this.keyEquivalence.hash(obj));
}
/* access modifiers changed from: package-private */
public void reclaimValue(WeakValueReference<K, V, E> weakValueReference) {
E entry = weakValueReference.getEntry();
int hash = entry.getHash();
segmentFor(hash).reclaimValue(entry.getKey(), hash, weakValueReference);
}
/* access modifiers changed from: package-private */
public void reclaimKey(E e) {
int hash = e.getHash();
segmentFor(hash).reclaimKey(e, hash);
}
/* access modifiers changed from: package-private */
public boolean isLiveForTesting(InternalEntry<K, V, ?> internalEntry) {
return segmentFor(internalEntry.getHash()).getLiveValueForTesting(internalEntry) != null;
}
/* access modifiers changed from: package-private */
public Segment<K, V, E, S> segmentFor(int i) {
return this.segments[(i >>> this.segmentShift) & this.segmentMask];
}
/* access modifiers changed from: package-private */
public Segment<K, V, E, S> createSegment(int i, int i2) {
return this.entryHelper.newSegment(this, i, i2);
}
/* access modifiers changed from: package-private */
public V getLiveValue(E e) {
if (e.getKey() == null) {
return null;
}
return e.getValue();
}
/* access modifiers changed from: package-private */
public final Segment<K, V, E, S>[] newSegmentArray(int i) {
return new Segment[i];
}
static abstract class Segment<K, V, E extends InternalEntry<K, V, E>, S extends Segment<K, V, E, S>> extends ReentrantLock {
volatile int count;
final MapMakerInternalMap<K, V, E, S> map;
final int maxSegmentSize;
int modCount;
final AtomicInteger readCount = new AtomicInteger();
@NullableDecl
volatile AtomicReferenceArray<E> table;
int threshold;
/* access modifiers changed from: package-private */
public abstract E castForTesting(InternalEntry<K, V, ?> internalEntry);
/* access modifiers changed from: package-private */
public void maybeClearReferenceQueues() {
}
/* access modifiers changed from: package-private */
public void maybeDrainReferenceQueues() {
}
/* access modifiers changed from: package-private */
public abstract S self();
Segment(MapMakerInternalMap<K, V, E, S> mapMakerInternalMap, int i, int i2) {
this.map = mapMakerInternalMap;
this.maxSegmentSize = i2;
initTable(newEntryArray(i));
}
/* access modifiers changed from: package-private */
public void setValue(E e, V v) {
this.map.entryHelper.setValue(self(), e, v);
}
/* access modifiers changed from: package-private */
public E copyEntry(E e, E e2) {
return this.map.entryHelper.copy(self(), e, e2);
}
/* access modifiers changed from: package-private */
public AtomicReferenceArray<E> newEntryArray(int i) {
return new AtomicReferenceArray<>(i);
}
/* access modifiers changed from: package-private */
public void initTable(AtomicReferenceArray<E> atomicReferenceArray) {
int length = (atomicReferenceArray.length() * 3) / 4;
this.threshold = length;
if (length == this.maxSegmentSize) {
this.threshold = length + 1;
}
this.table = atomicReferenceArray;
}
/* access modifiers changed from: package-private */
public ReferenceQueue<K> getKeyReferenceQueueForTesting() {
throw new AssertionError();
}
/* access modifiers changed from: package-private */
public ReferenceQueue<V> getValueReferenceQueueForTesting() {
throw new AssertionError();
}
/* access modifiers changed from: package-private */
public WeakValueReference<K, V, E> getWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry) {
throw new AssertionError();
}
/* access modifiers changed from: package-private */
public WeakValueReference<K, V, E> newWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, V v) {
throw new AssertionError();
}
/* access modifiers changed from: package-private */
public void setWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, WeakValueReference<K, V, ? extends InternalEntry<K, V, ?>> weakValueReference) {
throw new AssertionError();
}
/* access modifiers changed from: package-private */
public void setTableEntryForTesting(int i, InternalEntry<K, V, ?> internalEntry) {
this.table.set(i, castForTesting(internalEntry));
}
/* JADX WARNING: type inference failed for: r3v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* JADX WARNING: type inference failed for: r4v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 2 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public E copyForTesting(com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r3, @org.checkerframework.checker.nullness.compatqual.NullableDecl com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r4) {
/*
r2 = this;
com.google.common.collect.MapMakerInternalMap<K, V, E, S> r0 = r2.map
com.google.common.collect.MapMakerInternalMap$InternalEntryHelper<K, V, E, S> r0 = r0.entryHelper
com.google.common.collect.MapMakerInternalMap$Segment r1 = r2.self()
com.google.common.collect.MapMakerInternalMap$InternalEntry r3 = r2.castForTesting(r3)
com.google.common.collect.MapMakerInternalMap$InternalEntry r4 = r2.castForTesting(r4)
com.google.common.collect.MapMakerInternalMap$InternalEntry r3 = r0.copy(r1, r3, r4)
return r3
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.copyForTesting(com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry):com.google.common.collect.MapMakerInternalMap$InternalEntry");
}
/* JADX WARNING: type inference failed for: r3v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 1 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public void setValueForTesting(com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r3, V r4) {
/*
r2 = this;
com.google.common.collect.MapMakerInternalMap<K, V, E, S> r0 = r2.map
com.google.common.collect.MapMakerInternalMap$InternalEntryHelper<K, V, E, S> r0 = r0.entryHelper
com.google.common.collect.MapMakerInternalMap$Segment r1 = r2.self()
com.google.common.collect.MapMakerInternalMap$InternalEntry r3 = r2.castForTesting(r3)
r0.setValue(r1, r3, r4)
return
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.setValueForTesting(com.google.common.collect.MapMakerInternalMap$InternalEntry, java.lang.Object):void");
}
/* JADX WARNING: type inference failed for: r5v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 1 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public E newEntryForTesting(K r3, int r4, @org.checkerframework.checker.nullness.compatqual.NullableDecl com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r5) {
/*
r2 = this;
com.google.common.collect.MapMakerInternalMap<K, V, E, S> r0 = r2.map
com.google.common.collect.MapMakerInternalMap$InternalEntryHelper<K, V, E, S> r0 = r0.entryHelper
com.google.common.collect.MapMakerInternalMap$Segment r1 = r2.self()
com.google.common.collect.MapMakerInternalMap$InternalEntry r5 = r2.castForTesting(r5)
com.google.common.collect.MapMakerInternalMap$InternalEntry r3 = r0.newEntry(r1, r3, r4, r5)
return r3
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.newEntryForTesting(java.lang.Object, int, com.google.common.collect.MapMakerInternalMap$InternalEntry):com.google.common.collect.MapMakerInternalMap$InternalEntry");
}
/* JADX WARNING: type inference failed for: r1v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 1 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public boolean removeTableEntryForTesting(com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r1) {
/*
r0 = this;
com.google.common.collect.MapMakerInternalMap$InternalEntry r1 = r0.castForTesting(r1)
boolean r1 = r0.removeEntryForTesting(r1)
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.removeTableEntryForTesting(com.google.common.collect.MapMakerInternalMap$InternalEntry):boolean");
}
/* JADX WARNING: type inference failed for: r1v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* JADX WARNING: type inference failed for: r2v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 2 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public E removeFromChainForTesting(com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r1, com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r2) {
/*
r0 = this;
com.google.common.collect.MapMakerInternalMap$InternalEntry r1 = r0.castForTesting(r1)
com.google.common.collect.MapMakerInternalMap$InternalEntry r2 = r0.castForTesting(r2)
com.google.common.collect.MapMakerInternalMap$InternalEntry r1 = r0.removeFromChain(r1, r2)
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.removeFromChainForTesting(com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry):com.google.common.collect.MapMakerInternalMap$InternalEntry");
}
/* JADX WARNING: type inference failed for: r1v0, types: [com.google.common.collect.MapMakerInternalMap$InternalEntry, com.google.common.collect.MapMakerInternalMap$InternalEntry<K, V, ?>] */
/* access modifiers changed from: package-private */
/* JADX WARNING: Unknown variable types count: 1 */
@org.checkerframework.checker.nullness.compatqual.NullableDecl
/* Code decompiled incorrectly, please refer to instructions dump. */
public V getLiveValueForTesting(com.google.common.collect.MapMakerInternalMap.InternalEntry<K, V, ?> r1) {
/*
r0 = this;
com.google.common.collect.MapMakerInternalMap$InternalEntry r1 = r0.castForTesting(r1)
java.lang.Object r1 = r0.getLiveValue(r1)
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.Segment.getLiveValueForTesting(com.google.common.collect.MapMakerInternalMap$InternalEntry):java.lang.Object");
}
/* access modifiers changed from: package-private */
public void tryDrainReferenceQueues() {
if (tryLock()) {
try {
maybeDrainReferenceQueues();
} finally {
unlock();
}
}
}
/* access modifiers changed from: package-private */
public void drainKeyReferenceQueue(ReferenceQueue<K> referenceQueue) {
int i = 0;
do {
Reference<? extends K> poll = referenceQueue.poll();
if (poll != null) {
this.map.reclaimKey((InternalEntry) poll);
i++;
} else {
return;
}
} while (i != 16);
}
/* access modifiers changed from: package-private */
public void drainValueReferenceQueue(ReferenceQueue<V> referenceQueue) {
int i = 0;
do {
Reference<? extends V> poll = referenceQueue.poll();
if (poll != null) {
this.map.reclaimValue((WeakValueReference) poll);
i++;
} else {
return;
}
} while (i != 16);
}
/* access modifiers changed from: package-private */
public <T> void clearReferenceQueue(ReferenceQueue<T> referenceQueue) {
do {
} while (referenceQueue.poll() != null);
}
/* access modifiers changed from: package-private */
public E getFirst(int i) {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
return (InternalEntry) atomicReferenceArray.get(i & (atomicReferenceArray.length() - 1));
}
/* access modifiers changed from: package-private */
public E getEntry(Object obj, int i) {
if (this.count == 0) {
return null;
}
for (E first = getFirst(i); first != null; first = first.getNext()) {
if (first.getHash() == i) {
Object key = first.getKey();
if (key == null) {
tryDrainReferenceQueues();
} else if (this.map.keyEquivalence.equivalent(obj, key)) {
return first;
}
}
}
return null;
}
/* access modifiers changed from: package-private */
public E getLiveEntry(Object obj, int i) {
return getEntry(obj, i);
}
/* access modifiers changed from: package-private */
public V get(Object obj, int i) {
try {
InternalEntry liveEntry = getLiveEntry(obj, i);
if (liveEntry == null) {
return null;
}
V value = liveEntry.getValue();
if (value == null) {
tryDrainReferenceQueues();
}
postReadCleanup();
return value;
} finally {
postReadCleanup();
}
}
/* access modifiers changed from: package-private */
public boolean containsKey(Object obj, int i) {
try {
boolean z = false;
if (this.count != 0) {
InternalEntry liveEntry = getLiveEntry(obj, i);
if (!(liveEntry == null || liveEntry.getValue() == null)) {
z = true;
}
return z;
}
postReadCleanup();
return false;
} finally {
postReadCleanup();
}
}
/* JADX INFO: finally extract failed */
/* access modifiers changed from: package-private */
public boolean containsValue(Object obj) {
try {
if (this.count != 0) {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = atomicReferenceArray.length();
for (int i = 0; i < length; i++) {
for (InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(i); internalEntry != null; internalEntry = internalEntry.getNext()) {
Object liveValue = getLiveValue(internalEntry);
if (liveValue != null) {
if (this.map.valueEquivalence().equivalent(obj, liveValue)) {
postReadCleanup();
return true;
}
}
}
}
}
postReadCleanup();
return false;
} catch (Throwable th) {
postReadCleanup();
throw th;
}
}
/* access modifiers changed from: package-private */
public V put(K k, int i, V v, boolean z) {
lock();
try {
preWriteCleanup();
int i2 = this.count + 1;
if (i2 > this.threshold) {
expand();
i2 = this.count + 1;
}
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(k, key)) {
internalEntry2 = internalEntry2.getNext();
} else {
V value = internalEntry2.getValue();
if (value == null) {
this.modCount++;
setValue(internalEntry2, v);
this.count = this.count;
return null;
} else if (z) {
unlock();
return value;
} else {
this.modCount++;
setValue(internalEntry2, v);
unlock();
return value;
}
}
}
this.modCount++;
E newEntry = this.map.entryHelper.newEntry(self(), k, i, internalEntry);
setValue(newEntry, v);
atomicReferenceArray.set(length, newEntry);
this.count = i2;
unlock();
return null;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public void expand() {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = atomicReferenceArray.length();
if (length < 1073741824) {
int i = this.count;
AtomicReferenceArray<E> newEntryArray = newEntryArray(length << 1);
this.threshold = (newEntryArray.length() * 3) / 4;
int length2 = newEntryArray.length() - 1;
for (int i2 = 0; i2 < length; i2++) {
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(i2);
if (internalEntry != null) {
InternalEntry next = internalEntry.getNext();
int hash = internalEntry.getHash() & length2;
if (next == null) {
newEntryArray.set(hash, internalEntry);
} else {
InternalEntry internalEntry2 = internalEntry;
while (next != null) {
int hash2 = next.getHash() & length2;
if (hash2 != hash) {
internalEntry2 = next;
hash = hash2;
}
next = next.getNext();
}
newEntryArray.set(hash, internalEntry2);
while (internalEntry != internalEntry2) {
int hash3 = internalEntry.getHash() & length2;
InternalEntry copyEntry = copyEntry(internalEntry, (InternalEntry) newEntryArray.get(hash3));
if (copyEntry != null) {
newEntryArray.set(hash3, copyEntry);
} else {
i--;
}
internalEntry = internalEntry.getNext();
}
}
}
}
this.table = newEntryArray;
this.count = i;
}
}
/* access modifiers changed from: package-private */
public boolean replace(K k, int i, V v, V v2) {
lock();
try {
preWriteCleanup();
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(k, key)) {
internalEntry2 = internalEntry2.getNext();
} else {
Object value = internalEntry2.getValue();
if (value == null) {
if (isCollected(internalEntry2)) {
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
this.count--;
}
return false;
} else if (this.map.valueEquivalence().equivalent(v, value)) {
this.modCount++;
setValue(internalEntry2, v2);
unlock();
return true;
} else {
unlock();
return false;
}
}
}
unlock();
return false;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public V replace(K k, int i, V v) {
lock();
try {
preWriteCleanup();
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(k, key)) {
internalEntry2 = internalEntry2.getNext();
} else {
V value = internalEntry2.getValue();
if (value == null) {
if (isCollected(internalEntry2)) {
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
this.count--;
}
return null;
}
this.modCount++;
setValue(internalEntry2, v);
unlock();
return value;
}
}
unlock();
return null;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public V remove(Object obj, int i) {
lock();
try {
preWriteCleanup();
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(obj, key)) {
internalEntry2 = internalEntry2.getNext();
} else {
V value = internalEntry2.getValue();
if (value == null) {
if (!isCollected(internalEntry2)) {
unlock();
return null;
}
}
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
this.count--;
return value;
}
}
unlock();
return null;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public boolean remove(Object obj, int i, Object obj2) {
lock();
try {
preWriteCleanup();
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (true) {
boolean z = false;
if (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(obj, key)) {
internalEntry2 = internalEntry2.getNext();
} else {
if (this.map.valueEquivalence().equivalent(obj2, internalEntry2.getValue())) {
z = true;
} else if (!isCollected(internalEntry2)) {
unlock();
return false;
}
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
this.count--;
return z;
}
} else {
unlock();
return false;
}
}
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public void clear() {
if (this.count != 0) {
lock();
try {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
for (int i = 0; i < atomicReferenceArray.length(); i++) {
atomicReferenceArray.set(i, (Object) null);
}
maybeClearReferenceQueues();
this.readCount.set(0);
this.modCount++;
this.count = 0;
} finally {
unlock();
}
}
}
/* access modifiers changed from: package-private */
public E removeFromChain(E e, E e2) {
int i = this.count;
E next = e2.getNext();
while (e != e2) {
E copyEntry = copyEntry(e, next);
if (copyEntry != null) {
next = copyEntry;
} else {
i--;
}
e = e.getNext();
}
this.count = i;
return next;
}
/* access modifiers changed from: package-private */
public boolean reclaimKey(E e, int i) {
lock();
try {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = i & (atomicReferenceArray.length() - 1);
E e2 = (InternalEntry) atomicReferenceArray.get(length);
for (E e3 = e2; e3 != null; e3 = e3.getNext()) {
if (e3 == e) {
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(e2, e3));
this.count--;
return true;
}
}
unlock();
return false;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public boolean reclaimValue(K k, int i, WeakValueReference<K, V, E> weakValueReference) {
lock();
try {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(k, key)) {
internalEntry2 = internalEntry2.getNext();
} else if (((WeakValueEntry) internalEntry2).getValueReference() == weakValueReference) {
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
this.count--;
return true;
} else {
unlock();
return false;
}
}
unlock();
return false;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public boolean clearValueForTesting(K k, int i, WeakValueReference<K, V, ? extends InternalEntry<K, V, ?>> weakValueReference) {
lock();
try {
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = (atomicReferenceArray.length() - 1) & i;
InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(length);
InternalEntry internalEntry2 = internalEntry;
while (internalEntry2 != null) {
Object key = internalEntry2.getKey();
if (internalEntry2.getHash() != i || key == null || !this.map.keyEquivalence.equivalent(k, key)) {
internalEntry2 = internalEntry2.getNext();
} else if (((WeakValueEntry) internalEntry2).getValueReference() == weakValueReference) {
atomicReferenceArray.set(length, removeFromChain(internalEntry, internalEntry2));
return true;
} else {
unlock();
return false;
}
}
unlock();
return false;
} finally {
unlock();
}
}
/* access modifiers changed from: package-private */
public boolean removeEntryForTesting(E e) {
int hash = e.getHash();
AtomicReferenceArray<E> atomicReferenceArray = this.table;
int length = hash & (atomicReferenceArray.length() - 1);
E e2 = (InternalEntry) atomicReferenceArray.get(length);
for (E e3 = e2; e3 != null; e3 = e3.getNext()) {
if (e3 == e) {
this.modCount++;
atomicReferenceArray.set(length, removeFromChain(e2, e3));
this.count--;
return true;
}
}
return false;
}
static <K, V, E extends InternalEntry<K, V, E>> boolean isCollected(E e) {
return e.getValue() == null;
}
/* access modifiers changed from: package-private */
@NullableDecl
public V getLiveValue(E e) {
if (e.getKey() == null) {
tryDrainReferenceQueues();
return null;
}
V value = e.getValue();
if (value != null) {
return value;
}
tryDrainReferenceQueues();
return null;
}
/* access modifiers changed from: package-private */
public void postReadCleanup() {
if ((this.readCount.incrementAndGet() & 63) == 0) {
runCleanup();
}
}
/* access modifiers changed from: package-private */
public void preWriteCleanup() {
runLockedCleanup();
}
/* access modifiers changed from: package-private */
public void runCleanup() {
runLockedCleanup();
}
/* access modifiers changed from: package-private */
public void runLockedCleanup() {
if (tryLock()) {
try {
maybeDrainReferenceQueues();
this.readCount.set(0);
} finally {
unlock();
}
}
}
}
static final class StrongKeyStrongValueSegment<K, V> extends Segment<K, V, StrongKeyStrongValueEntry<K, V>, StrongKeyStrongValueSegment<K, V>> {
/* access modifiers changed from: package-private */
public StrongKeyStrongValueSegment<K, V> self() {
return this;
}
StrongKeyStrongValueSegment(MapMakerInternalMap<K, V, StrongKeyStrongValueEntry<K, V>, StrongKeyStrongValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
public StrongKeyStrongValueEntry<K, V> castForTesting(InternalEntry<K, V, ?> internalEntry) {
return (StrongKeyStrongValueEntry) internalEntry;
}
}
static final class StrongKeyWeakValueSegment<K, V> extends Segment<K, V, StrongKeyWeakValueEntry<K, V>, StrongKeyWeakValueSegment<K, V>> {
/* access modifiers changed from: private */
public final ReferenceQueue<V> queueForValues = new ReferenceQueue<>();
/* access modifiers changed from: package-private */
public StrongKeyWeakValueSegment<K, V> self() {
return this;
}
StrongKeyWeakValueSegment(MapMakerInternalMap<K, V, StrongKeyWeakValueEntry<K, V>, StrongKeyWeakValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
/* access modifiers changed from: package-private */
public ReferenceQueue<V> getValueReferenceQueueForTesting() {
return this.queueForValues;
}
public StrongKeyWeakValueEntry<K, V> castForTesting(InternalEntry<K, V, ?> internalEntry) {
return (StrongKeyWeakValueEntry) internalEntry;
}
public WeakValueReference<K, V, StrongKeyWeakValueEntry<K, V>> getWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry) {
return castForTesting((InternalEntry) internalEntry).getValueReference();
}
public WeakValueReference<K, V, StrongKeyWeakValueEntry<K, V>> newWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, V v) {
return new WeakValueReferenceImpl(this.queueForValues, v, castForTesting((InternalEntry) internalEntry));
}
public void setWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, WeakValueReference<K, V, ? extends InternalEntry<K, V, ?>> weakValueReference) {
StrongKeyWeakValueEntry castForTesting = castForTesting((InternalEntry) internalEntry);
WeakValueReference access$600 = castForTesting.valueReference;
WeakValueReference unused = castForTesting.valueReference = weakValueReference;
access$600.clear();
}
/* access modifiers changed from: package-private */
public void maybeDrainReferenceQueues() {
drainValueReferenceQueue(this.queueForValues);
}
/* access modifiers changed from: package-private */
public void maybeClearReferenceQueues() {
clearReferenceQueue(this.queueForValues);
}
}
static final class StrongKeyDummyValueSegment<K> extends Segment<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>, StrongKeyDummyValueSegment<K>> {
/* access modifiers changed from: package-private */
public StrongKeyDummyValueSegment<K> self() {
return this;
}
StrongKeyDummyValueSegment(MapMakerInternalMap<K, MapMaker.Dummy, StrongKeyDummyValueEntry<K>, StrongKeyDummyValueSegment<K>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
public StrongKeyDummyValueEntry<K> castForTesting(InternalEntry<K, MapMaker.Dummy, ?> internalEntry) {
return (StrongKeyDummyValueEntry) internalEntry;
}
}
static final class WeakKeyStrongValueSegment<K, V> extends Segment<K, V, WeakKeyStrongValueEntry<K, V>, WeakKeyStrongValueSegment<K, V>> {
/* access modifiers changed from: private */
public final ReferenceQueue<K> queueForKeys = new ReferenceQueue<>();
/* access modifiers changed from: package-private */
public WeakKeyStrongValueSegment<K, V> self() {
return this;
}
WeakKeyStrongValueSegment(MapMakerInternalMap<K, V, WeakKeyStrongValueEntry<K, V>, WeakKeyStrongValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
/* access modifiers changed from: package-private */
public ReferenceQueue<K> getKeyReferenceQueueForTesting() {
return this.queueForKeys;
}
public WeakKeyStrongValueEntry<K, V> castForTesting(InternalEntry<K, V, ?> internalEntry) {
return (WeakKeyStrongValueEntry) internalEntry;
}
/* access modifiers changed from: package-private */
public void maybeDrainReferenceQueues() {
drainKeyReferenceQueue(this.queueForKeys);
}
/* access modifiers changed from: package-private */
public void maybeClearReferenceQueues() {
clearReferenceQueue(this.queueForKeys);
}
}
static final class WeakKeyWeakValueSegment<K, V> extends Segment<K, V, WeakKeyWeakValueEntry<K, V>, WeakKeyWeakValueSegment<K, V>> {
/* access modifiers changed from: private */
public final ReferenceQueue<K> queueForKeys = new ReferenceQueue<>();
/* access modifiers changed from: private */
public final ReferenceQueue<V> queueForValues = new ReferenceQueue<>();
/* access modifiers changed from: package-private */
public WeakKeyWeakValueSegment<K, V> self() {
return this;
}
WeakKeyWeakValueSegment(MapMakerInternalMap<K, V, WeakKeyWeakValueEntry<K, V>, WeakKeyWeakValueSegment<K, V>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
/* access modifiers changed from: package-private */
public ReferenceQueue<K> getKeyReferenceQueueForTesting() {
return this.queueForKeys;
}
/* access modifiers changed from: package-private */
public ReferenceQueue<V> getValueReferenceQueueForTesting() {
return this.queueForValues;
}
public WeakKeyWeakValueEntry<K, V> castForTesting(InternalEntry<K, V, ?> internalEntry) {
return (WeakKeyWeakValueEntry) internalEntry;
}
public WeakValueReference<K, V, WeakKeyWeakValueEntry<K, V>> getWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry) {
return castForTesting((InternalEntry) internalEntry).getValueReference();
}
public WeakValueReference<K, V, WeakKeyWeakValueEntry<K, V>> newWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, V v) {
return new WeakValueReferenceImpl(this.queueForValues, v, castForTesting((InternalEntry) internalEntry));
}
public void setWeakValueReferenceForTesting(InternalEntry<K, V, ?> internalEntry, WeakValueReference<K, V, ? extends InternalEntry<K, V, ?>> weakValueReference) {
WeakKeyWeakValueEntry castForTesting = castForTesting((InternalEntry) internalEntry);
WeakValueReference access$700 = castForTesting.valueReference;
WeakValueReference unused = castForTesting.valueReference = weakValueReference;
access$700.clear();
}
/* access modifiers changed from: package-private */
public void maybeDrainReferenceQueues() {
drainKeyReferenceQueue(this.queueForKeys);
drainValueReferenceQueue(this.queueForValues);
}
/* access modifiers changed from: package-private */
public void maybeClearReferenceQueues() {
clearReferenceQueue(this.queueForKeys);
}
}
static final class WeakKeyDummyValueSegment<K> extends Segment<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>, WeakKeyDummyValueSegment<K>> {
/* access modifiers changed from: private */
public final ReferenceQueue<K> queueForKeys = new ReferenceQueue<>();
/* access modifiers changed from: package-private */
public WeakKeyDummyValueSegment<K> self() {
return this;
}
WeakKeyDummyValueSegment(MapMakerInternalMap<K, MapMaker.Dummy, WeakKeyDummyValueEntry<K>, WeakKeyDummyValueSegment<K>> mapMakerInternalMap, int i, int i2) {
super(mapMakerInternalMap, i, i2);
}
/* access modifiers changed from: package-private */
public ReferenceQueue<K> getKeyReferenceQueueForTesting() {
return this.queueForKeys;
}
public WeakKeyDummyValueEntry<K> castForTesting(InternalEntry<K, MapMaker.Dummy, ?> internalEntry) {
return (WeakKeyDummyValueEntry) internalEntry;
}
/* access modifiers changed from: package-private */
public void maybeDrainReferenceQueues() {
drainKeyReferenceQueue(this.queueForKeys);
}
/* access modifiers changed from: package-private */
public void maybeClearReferenceQueues() {
clearReferenceQueue(this.queueForKeys);
}
}
static final class CleanupMapTask implements Runnable {
final WeakReference<MapMakerInternalMap<?, ?, ?, ?>> mapReference;
public CleanupMapTask(MapMakerInternalMap<?, ?, ?, ?> mapMakerInternalMap) {
this.mapReference = new WeakReference<>(mapMakerInternalMap);
}
public void run() {
MapMakerInternalMap mapMakerInternalMap = (MapMakerInternalMap) this.mapReference.get();
if (mapMakerInternalMap != null) {
for (Segment<K, V, E, S> runCleanup : mapMakerInternalMap.segments) {
runCleanup.runCleanup();
}
return;
}
throw new CancellationException();
}
}
/* access modifiers changed from: package-private */
public Strength keyStrength() {
return this.entryHelper.keyStrength();
}
/* access modifiers changed from: package-private */
public Strength valueStrength() {
return this.entryHelper.valueStrength();
}
/* access modifiers changed from: package-private */
public Equivalence<Object> valueEquivalence() {
return this.entryHelper.valueStrength().defaultEquivalence();
}
public boolean isEmpty() {
Segment<K, V, E, S>[] segmentArr = this.segments;
long j = 0;
for (int i = 0; i < segmentArr.length; i++) {
if (segmentArr[i].count != 0) {
return false;
}
j += (long) segmentArr[i].modCount;
}
if (j == 0) {
return true;
}
for (int i2 = 0; i2 < segmentArr.length; i2++) {
if (segmentArr[i2].count != 0) {
return false;
}
j -= (long) segmentArr[i2].modCount;
}
if (j == 0) {
return true;
}
return false;
}
public int size() {
Segment<K, V, E, S>[] segmentArr = this.segments;
long j = 0;
for (Segment<K, V, E, S> segment : segmentArr) {
j += (long) segment.count;
}
return Ints.saturatedCast(j);
}
public V get(@NullableDecl Object obj) {
if (obj == null) {
return null;
}
int hash = hash(obj);
return segmentFor(hash).get(obj, hash);
}
/* access modifiers changed from: package-private */
public E getEntry(@NullableDecl Object obj) {
if (obj == null) {
return null;
}
int hash = hash(obj);
return segmentFor(hash).getEntry(obj, hash);
}
public boolean containsKey(@NullableDecl Object obj) {
if (obj == null) {
return false;
}
int hash = hash(obj);
return segmentFor(hash).containsKey(obj, hash);
}
public boolean containsValue(@NullableDecl Object obj) {
Object obj2 = obj;
if (obj2 == null) {
return false;
}
Segment<K, V, E, S>[] segmentArr = this.segments;
long j = -1;
int i = 0;
while (i < 3) {
long j2 = 0;
for (Segment<K, V, E, S> segment : segmentArr) {
int i2 = segment.count;
AtomicReferenceArray<E> atomicReferenceArray = segment.table;
for (int i3 = 0; i3 < atomicReferenceArray.length(); i3++) {
for (InternalEntry internalEntry = (InternalEntry) atomicReferenceArray.get(i3); internalEntry != null; internalEntry = internalEntry.getNext()) {
V liveValue = segment.getLiveValue(internalEntry);
if (liveValue != null && valueEquivalence().equivalent(obj2, liveValue)) {
return true;
}
}
}
j2 += (long) segment.modCount;
}
if (j2 == j) {
return false;
}
i++;
j = j2;
}
return false;
}
public V put(K k, V v) {
Preconditions.checkNotNull(k);
Preconditions.checkNotNull(v);
int hash = hash(k);
return segmentFor(hash).put(k, hash, v, false);
}
public V putIfAbsent(K k, V v) {
Preconditions.checkNotNull(k);
Preconditions.checkNotNull(v);
int hash = hash(k);
return segmentFor(hash).put(k, hash, v, true);
}
public void putAll(Map<? extends K, ? extends V> map) {
for (Map.Entry next : map.entrySet()) {
put(next.getKey(), next.getValue());
}
}
public V remove(@NullableDecl Object obj) {
if (obj == null) {
return null;
}
int hash = hash(obj);
return segmentFor(hash).remove(obj, hash);
}
public boolean remove(@NullableDecl Object obj, @NullableDecl Object obj2) {
if (obj == null || obj2 == null) {
return false;
}
int hash = hash(obj);
return segmentFor(hash).remove(obj, hash, obj2);
}
public boolean replace(K k, @NullableDecl V v, V v2) {
Preconditions.checkNotNull(k);
Preconditions.checkNotNull(v2);
if (v == null) {
return false;
}
int hash = hash(k);
return segmentFor(hash).replace(k, hash, v, v2);
}
public V replace(K k, V v) {
Preconditions.checkNotNull(k);
Preconditions.checkNotNull(v);
int hash = hash(k);
return segmentFor(hash).replace(k, hash, v);
}
public void clear() {
for (Segment<K, V, E, S> clear : this.segments) {
clear.clear();
}
}
public Set<K> keySet() {
Set<K> set = this.keySet;
if (set != null) {
return set;
}
KeySet keySet2 = new KeySet();
this.keySet = keySet2;
return keySet2;
}
public Collection<V> values() {
Collection<V> collection = this.values;
if (collection != null) {
return collection;
}
Values values2 = new Values();
this.values = values2;
return values2;
}
public Set<Map.Entry<K, V>> entrySet() {
Set<Map.Entry<K, V>> set = this.entrySet;
if (set != null) {
return set;
}
EntrySet entrySet2 = new EntrySet();
this.entrySet = entrySet2;
return entrySet2;
}
abstract class HashIterator<T> implements Iterator<T> {
@NullableDecl
Segment<K, V, E, S> currentSegment;
@NullableDecl
AtomicReferenceArray<E> currentTable;
@NullableDecl
MapMakerInternalMap<K, V, E, S>.WriteThroughEntry lastReturned;
@NullableDecl
E nextEntry;
@NullableDecl
MapMakerInternalMap<K, V, E, S>.WriteThroughEntry nextExternal;
int nextSegmentIndex;
int nextTableIndex = -1;
public abstract T next();
HashIterator() {
this.nextSegmentIndex = MapMakerInternalMap.this.segments.length - 1;
advance();
}
/* access modifiers changed from: package-private */
public final void advance() {
this.nextExternal = null;
if (!nextInChain() && !nextInTable()) {
while (this.nextSegmentIndex >= 0) {
Segment<K, V, E, S>[] segmentArr = MapMakerInternalMap.this.segments;
int i = this.nextSegmentIndex;
this.nextSegmentIndex = i - 1;
Segment<K, V, E, S> segment = segmentArr[i];
this.currentSegment = segment;
if (segment.count != 0) {
AtomicReferenceArray<E> atomicReferenceArray = this.currentSegment.table;
this.currentTable = atomicReferenceArray;
this.nextTableIndex = atomicReferenceArray.length() - 1;
if (nextInTable()) {
return;
}
}
}
}
}
/* access modifiers changed from: package-private */
public boolean nextInChain() {
E e = this.nextEntry;
if (e == null) {
return false;
}
while (true) {
this.nextEntry = e.getNext();
E e2 = this.nextEntry;
if (e2 == null) {
return false;
}
if (advanceTo(e2)) {
return true;
}
e = this.nextEntry;
}
}
/* access modifiers changed from: package-private */
public boolean nextInTable() {
while (true) {
int i = this.nextTableIndex;
if (i < 0) {
return false;
}
AtomicReferenceArray<E> atomicReferenceArray = this.currentTable;
this.nextTableIndex = i - 1;
E e = (InternalEntry) atomicReferenceArray.get(i);
this.nextEntry = e;
if (e != null && (advanceTo(e) || nextInChain())) {
return true;
}
}
}
/* access modifiers changed from: package-private */
public boolean advanceTo(E e) {
boolean z;
try {
Object key = e.getKey();
Object liveValue = MapMakerInternalMap.this.getLiveValue(e);
if (liveValue != null) {
this.nextExternal = new WriteThroughEntry(key, liveValue);
z = true;
} else {
z = false;
}
return z;
} finally {
this.currentSegment.postReadCleanup();
}
}
public boolean hasNext() {
return this.nextExternal != null;
}
/* access modifiers changed from: package-private */
public MapMakerInternalMap<K, V, E, S>.WriteThroughEntry nextEntry() {
MapMakerInternalMap<K, V, E, S>.WriteThroughEntry writeThroughEntry = this.nextExternal;
if (writeThroughEntry != null) {
this.lastReturned = writeThroughEntry;
advance();
return this.lastReturned;
}
throw new NoSuchElementException();
}
public void remove() {
CollectPreconditions.checkRemove(this.lastReturned != null);
MapMakerInternalMap.this.remove(this.lastReturned.getKey());
this.lastReturned = null;
}
}
final class KeyIterator extends MapMakerInternalMap<K, V, E, S>.HashIterator<K> {
KeyIterator(MapMakerInternalMap mapMakerInternalMap) {
super();
}
public K next() {
return nextEntry().getKey();
}
}
final class ValueIterator extends MapMakerInternalMap<K, V, E, S>.HashIterator<V> {
ValueIterator(MapMakerInternalMap mapMakerInternalMap) {
super();
}
public V next() {
return nextEntry().getValue();
}
}
final class WriteThroughEntry extends AbstractMapEntry<K, V> {
final K key;
V value;
WriteThroughEntry(K k, V v) {
this.key = k;
this.value = v;
}
public K getKey() {
return this.key;
}
public V getValue() {
return this.value;
}
public boolean equals(@NullableDecl Object obj) {
if (!(obj instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) obj;
if (!this.key.equals(entry.getKey()) || !this.value.equals(entry.getValue())) {
return false;
}
return true;
}
public int hashCode() {
return this.key.hashCode() ^ this.value.hashCode();
}
public V setValue(V v) {
V put = MapMakerInternalMap.this.put(this.key, v);
this.value = v;
return put;
}
}
final class EntryIterator extends MapMakerInternalMap<K, V, E, S>.HashIterator<Map.Entry<K, V>> {
EntryIterator(MapMakerInternalMap mapMakerInternalMap) {
super();
}
public Map.Entry<K, V> next() {
return nextEntry();
}
}
final class KeySet extends SafeToArraySet<K> {
KeySet() {
super();
}
public Iterator<K> iterator() {
return new KeyIterator(MapMakerInternalMap.this);
}
public int size() {
return MapMakerInternalMap.this.size();
}
public boolean isEmpty() {
return MapMakerInternalMap.this.isEmpty();
}
public boolean contains(Object obj) {
return MapMakerInternalMap.this.containsKey(obj);
}
public boolean remove(Object obj) {
return MapMakerInternalMap.this.remove(obj) != null;
}
public void clear() {
MapMakerInternalMap.this.clear();
}
}
final class Values extends AbstractCollection<V> {
Values() {
}
public Iterator<V> iterator() {
return new ValueIterator(MapMakerInternalMap.this);
}
public int size() {
return MapMakerInternalMap.this.size();
}
public boolean isEmpty() {
return MapMakerInternalMap.this.isEmpty();
}
public boolean contains(Object obj) {
return MapMakerInternalMap.this.containsValue(obj);
}
public void clear() {
MapMakerInternalMap.this.clear();
}
public Object[] toArray() {
return MapMakerInternalMap.toArrayList(this).toArray();
}
public <T> T[] toArray(T[] tArr) {
return MapMakerInternalMap.toArrayList(this).toArray(tArr);
}
}
final class EntrySet extends SafeToArraySet<Map.Entry<K, V>> {
EntrySet() {
super();
}
public Iterator<Map.Entry<K, V>> iterator() {
return new EntryIterator(MapMakerInternalMap.this);
}
/* JADX WARNING: Code restructure failed: missing block: B:3:0x0006, code lost:
r4 = (java.util.Map.Entry) r4;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
public boolean contains(java.lang.Object r4) {
/*
r3 = this;
boolean r0 = r4 instanceof java.util.Map.Entry
r1 = 0
if (r0 != 0) goto L_0x0006
return r1
L_0x0006:
java.util.Map$Entry r4 = (java.util.Map.Entry) r4
java.lang.Object r0 = r4.getKey()
if (r0 != 0) goto L_0x000f
return r1
L_0x000f:
com.google.common.collect.MapMakerInternalMap r2 = com.google.common.collect.MapMakerInternalMap.this
java.lang.Object r0 = r2.get(r0)
if (r0 == 0) goto L_0x0028
com.google.common.collect.MapMakerInternalMap r2 = com.google.common.collect.MapMakerInternalMap.this
com.google.common.base.Equivalence r2 = r2.valueEquivalence()
java.lang.Object r4 = r4.getValue()
boolean r4 = r2.equivalent(r4, r0)
if (r4 == 0) goto L_0x0028
r1 = 1
L_0x0028:
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.EntrySet.contains(java.lang.Object):boolean");
}
/* JADX WARNING: Code restructure failed: missing block: B:3:0x0006, code lost:
r4 = (java.util.Map.Entry) r4;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
public boolean remove(java.lang.Object r4) {
/*
r3 = this;
boolean r0 = r4 instanceof java.util.Map.Entry
r1 = 0
if (r0 != 0) goto L_0x0006
return r1
L_0x0006:
java.util.Map$Entry r4 = (java.util.Map.Entry) r4
java.lang.Object r0 = r4.getKey()
if (r0 == 0) goto L_0x001b
com.google.common.collect.MapMakerInternalMap r2 = com.google.common.collect.MapMakerInternalMap.this
java.lang.Object r4 = r4.getValue()
boolean r4 = r2.remove(r0, r4)
if (r4 == 0) goto L_0x001b
r1 = 1
L_0x001b:
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.MapMakerInternalMap.EntrySet.remove(java.lang.Object):boolean");
}
public int size() {
return MapMakerInternalMap.this.size();
}
public boolean isEmpty() {
return MapMakerInternalMap.this.isEmpty();
}
public void clear() {
MapMakerInternalMap.this.clear();
}
}
private static abstract class SafeToArraySet<E> extends AbstractSet<E> {
private SafeToArraySet() {
}
public Object[] toArray() {
return MapMakerInternalMap.toArrayList(this).toArray();
}
public <T> T[] toArray(T[] tArr) {
return MapMakerInternalMap.toArrayList(this).toArray(tArr);
}
}
/* access modifiers changed from: private */
public static <E> ArrayList<E> toArrayList(Collection<E> collection) {
ArrayList<E> arrayList = new ArrayList<>(collection.size());
Iterators.addAll(arrayList, collection.iterator());
return arrayList;
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializationProxy(this.entryHelper.keyStrength(), this.entryHelper.valueStrength(), this.keyEquivalence, this.entryHelper.valueStrength().defaultEquivalence(), this.concurrencyLevel, this);
}
static abstract class AbstractSerializationProxy<K, V> extends ForwardingConcurrentMap<K, V> implements Serializable {
private static final long serialVersionUID = 3;
final int concurrencyLevel;
transient ConcurrentMap<K, V> delegate;
final Equivalence<Object> keyEquivalence;
final Strength keyStrength;
final Equivalence<Object> valueEquivalence;
final Strength valueStrength;
AbstractSerializationProxy(Strength strength, Strength strength2, Equivalence<Object> equivalence, Equivalence<Object> equivalence2, int i, ConcurrentMap<K, V> concurrentMap) {
this.keyStrength = strength;
this.valueStrength = strength2;
this.keyEquivalence = equivalence;
this.valueEquivalence = equivalence2;
this.concurrencyLevel = i;
this.delegate = concurrentMap;
}
/* access modifiers changed from: protected */
public ConcurrentMap<K, V> delegate() {
return this.delegate;
}
/* access modifiers changed from: package-private */
public void writeMapTo(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.writeInt(this.delegate.size());
for (Map.Entry entry : this.delegate.entrySet()) {
objectOutputStream.writeObject(entry.getKey());
objectOutputStream.writeObject(entry.getValue());
}
objectOutputStream.writeObject((Object) null);
}
/* access modifiers changed from: package-private */
public MapMaker readMapMaker(ObjectInputStream objectInputStream) throws IOException {
return new MapMaker().initialCapacity(objectInputStream.readInt()).setKeyStrength(this.keyStrength).setValueStrength(this.valueStrength).keyEquivalence(this.keyEquivalence).concurrencyLevel(this.concurrencyLevel);
}
/* access modifiers changed from: package-private */
public void readEntries(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
while (true) {
Object readObject = objectInputStream.readObject();
if (readObject != null) {
this.delegate.put(readObject, objectInputStream.readObject());
} else {
return;
}
}
}
}
private static final class SerializationProxy<K, V> extends AbstractSerializationProxy<K, V> {
private static final long serialVersionUID = 3;
SerializationProxy(Strength strength, Strength strength2, Equivalence<Object> equivalence, Equivalence<Object> equivalence2, int i, ConcurrentMap<K, V> concurrentMap) {
super(strength, strength2, equivalence, equivalence2, i, concurrentMap);
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.defaultWriteObject();
writeMapTo(objectOutputStream);
}
private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
objectInputStream.defaultReadObject();
this.delegate = readMapMaker(objectInputStream).makeMap();
readEntries(objectInputStream);
}
private Object readResolve() {
return this.delegate;
}
}
}
Download file