CrackMe.apk
Download file
package com.google.common.cache;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.cache.LocalCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Locale;
import java.util.concurrent.TimeUnit;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class CacheBuilderSpec {
private static final Splitter KEYS_SPLITTER = Splitter.on(',').trimResults();
private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').trimResults();
private static final ImmutableMap<String, ValueParser> VALUE_PARSERS = ImmutableMap.builder().put("initialCapacity", new InitialCapacityParser()).put("maximumSize", new MaximumSizeParser()).put("maximumWeight", new MaximumWeightParser()).put("concurrencyLevel", new ConcurrencyLevelParser()).put("weakKeys", new KeyStrengthParser(LocalCache.Strength.WEAK)).put("softValues", new ValueStrengthParser(LocalCache.Strength.SOFT)).put("weakValues", new ValueStrengthParser(LocalCache.Strength.WEAK)).put("recordStats", new RecordStatsParser()).put("expireAfterAccess", new AccessDurationParser()).put("expireAfterWrite", new WriteDurationParser()).put("refreshAfterWrite", new RefreshDurationParser()).put("refreshInterval", new RefreshDurationParser()).build();
long accessExpirationDuration;
@CheckForNull
TimeUnit accessExpirationTimeUnit;
@CheckForNull
Integer concurrencyLevel;
@CheckForNull
Integer initialCapacity;
@CheckForNull
LocalCache.Strength keyStrength;
@CheckForNull
Long maximumSize;
@CheckForNull
Long maximumWeight;
@CheckForNull
Boolean recordStats;
long refreshDuration;
@CheckForNull
TimeUnit refreshTimeUnit;
private final String specification;
@CheckForNull
LocalCache.Strength valueStrength;
long writeExpirationDuration;
@CheckForNull
TimeUnit writeExpirationTimeUnit;
private interface ValueParser {
void parse(CacheBuilderSpec cacheBuilderSpec, String str, @CheckForNull String str2);
}
private CacheBuilderSpec(String str) {
this.specification = str;
}
public static CacheBuilderSpec parse(String str) {
CacheBuilderSpec cacheBuilderSpec = new CacheBuilderSpec(str);
if (!str.isEmpty()) {
for (String next : KEYS_SPLITTER.split(str)) {
ImmutableList<E> copyOf = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(next));
Preconditions.checkArgument(!copyOf.isEmpty(), "blank key-value pair");
boolean z = false;
Preconditions.checkArgument(copyOf.size() <= 2, "key-value pair %s with more than one equals sign", (Object) next);
String str2 = (String) copyOf.get(0);
ValueParser valueParser = VALUE_PARSERS.get(str2);
if (valueParser != null) {
z = true;
}
Preconditions.checkArgument(z, "unknown key %s", (Object) str2);
valueParser.parse(cacheBuilderSpec, str2, copyOf.size() == 1 ? null : (String) copyOf.get(1));
}
}
return cacheBuilderSpec;
}
public static CacheBuilderSpec disableCaching() {
return parse("maximumSize=0");
}
/* access modifiers changed from: package-private */
public CacheBuilder<Object, Object> toCacheBuilder() {
CacheBuilder<Object, Object> newBuilder = CacheBuilder.newBuilder();
Integer num = this.initialCapacity;
if (num != null) {
newBuilder.initialCapacity(num.intValue());
}
Long l = this.maximumSize;
if (l != null) {
newBuilder.maximumSize(l.longValue());
}
Long l2 = this.maximumWeight;
if (l2 != null) {
newBuilder.maximumWeight(l2.longValue());
}
Integer num2 = this.concurrencyLevel;
if (num2 != null) {
newBuilder.concurrencyLevel(num2.intValue());
}
if (this.keyStrength != null) {
if (AnonymousClass1.$SwitchMap$com$google$common$cache$LocalCache$Strength[this.keyStrength.ordinal()] == 1) {
newBuilder.weakKeys();
} else {
throw new AssertionError();
}
}
if (this.valueStrength != null) {
int i = AnonymousClass1.$SwitchMap$com$google$common$cache$LocalCache$Strength[this.valueStrength.ordinal()];
if (i == 1) {
newBuilder.weakValues();
} else if (i == 2) {
newBuilder.softValues();
} else {
throw new AssertionError();
}
}
Boolean bool = this.recordStats;
if (bool != null && bool.booleanValue()) {
newBuilder.recordStats();
}
TimeUnit timeUnit = this.writeExpirationTimeUnit;
if (timeUnit != null) {
newBuilder.expireAfterWrite(this.writeExpirationDuration, timeUnit);
}
TimeUnit timeUnit2 = this.accessExpirationTimeUnit;
if (timeUnit2 != null) {
newBuilder.expireAfterAccess(this.accessExpirationDuration, timeUnit2);
}
TimeUnit timeUnit3 = this.refreshTimeUnit;
if (timeUnit3 != null) {
newBuilder.refreshAfterWrite(this.refreshDuration, timeUnit3);
}
return newBuilder;
}
/* renamed from: com.google.common.cache.CacheBuilderSpec$1 reason: invalid class name */
static /* synthetic */ class AnonymousClass1 {
static final /* synthetic */ int[] $SwitchMap$com$google$common$cache$LocalCache$Strength;
/* JADX WARNING: Can't wrap try/catch for region: R(6:0|1|2|3|4|6) */
/* JADX WARNING: Code restructure failed: missing block: B:7:?, code lost:
return;
*/
/* JADX WARNING: Failed to process nested try/catch */
/* JADX WARNING: Missing exception handler attribute for start block: B:3:0x0012 */
static {
/*
com.google.common.cache.LocalCache$Strength[] r0 = com.google.common.cache.LocalCache.Strength.values()
int r0 = r0.length
int[] r0 = new int[r0]
$SwitchMap$com$google$common$cache$LocalCache$Strength = r0
com.google.common.cache.LocalCache$Strength r1 = com.google.common.cache.LocalCache.Strength.WEAK // Catch:{ NoSuchFieldError -> 0x0012 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0012 }
r2 = 1
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0012 }
L_0x0012:
int[] r0 = $SwitchMap$com$google$common$cache$LocalCache$Strength // Catch:{ NoSuchFieldError -> 0x001d }
com.google.common.cache.LocalCache$Strength r1 = com.google.common.cache.LocalCache.Strength.SOFT // Catch:{ NoSuchFieldError -> 0x001d }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x001d }
r2 = 2
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x001d }
L_0x001d:
return
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.cache.CacheBuilderSpec.AnonymousClass1.<clinit>():void");
}
}
public String toParsableString() {
return this.specification;
}
public String toString() {
return MoreObjects.toStringHelper((Object) this).addValue((Object) toParsableString()).toString();
}
public int hashCode() {
return Objects.hashCode(this.initialCapacity, this.maximumSize, this.maximumWeight, this.concurrencyLevel, this.keyStrength, this.valueStrength, this.recordStats, durationInNanos(this.writeExpirationDuration, this.writeExpirationTimeUnit), durationInNanos(this.accessExpirationDuration, this.accessExpirationTimeUnit), durationInNanos(this.refreshDuration, this.refreshTimeUnit));
}
public boolean equals(@CheckForNull Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof CacheBuilderSpec)) {
return false;
}
CacheBuilderSpec cacheBuilderSpec = (CacheBuilderSpec) obj;
if (!Objects.equal(this.initialCapacity, cacheBuilderSpec.initialCapacity) || !Objects.equal(this.maximumSize, cacheBuilderSpec.maximumSize) || !Objects.equal(this.maximumWeight, cacheBuilderSpec.maximumWeight) || !Objects.equal(this.concurrencyLevel, cacheBuilderSpec.concurrencyLevel) || !Objects.equal(this.keyStrength, cacheBuilderSpec.keyStrength) || !Objects.equal(this.valueStrength, cacheBuilderSpec.valueStrength) || !Objects.equal(this.recordStats, cacheBuilderSpec.recordStats) || !Objects.equal(durationInNanos(this.writeExpirationDuration, this.writeExpirationTimeUnit), durationInNanos(cacheBuilderSpec.writeExpirationDuration, cacheBuilderSpec.writeExpirationTimeUnit)) || !Objects.equal(durationInNanos(this.accessExpirationDuration, this.accessExpirationTimeUnit), durationInNanos(cacheBuilderSpec.accessExpirationDuration, cacheBuilderSpec.accessExpirationTimeUnit)) || !Objects.equal(durationInNanos(this.refreshDuration, this.refreshTimeUnit), durationInNanos(cacheBuilderSpec.refreshDuration, cacheBuilderSpec.refreshTimeUnit))) {
return false;
}
return true;
}
@CheckForNull
private static Long durationInNanos(long j, @CheckForNull TimeUnit timeUnit) {
if (timeUnit == null) {
return null;
}
return Long.valueOf(timeUnit.toNanos(j));
}
static abstract class IntegerParser implements ValueParser {
/* access modifiers changed from: protected */
public abstract void parseInteger(CacheBuilderSpec cacheBuilderSpec, int i);
IntegerParser() {
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, String str2) {
if (!Strings.isNullOrEmpty(str2)) {
try {
parseInteger(cacheBuilderSpec, Integer.parseInt(str2));
} catch (NumberFormatException e) {
throw new IllegalArgumentException(CacheBuilderSpec.format("key %s value set to %s, must be integer", str, str2), e);
}
} else {
StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 21);
sb.append("value of key ");
sb.append(str);
sb.append(" omitted");
throw new IllegalArgumentException(sb.toString());
}
}
}
static abstract class LongParser implements ValueParser {
/* access modifiers changed from: protected */
public abstract void parseLong(CacheBuilderSpec cacheBuilderSpec, long j);
LongParser() {
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, String str2) {
if (!Strings.isNullOrEmpty(str2)) {
try {
parseLong(cacheBuilderSpec, Long.parseLong(str2));
} catch (NumberFormatException e) {
throw new IllegalArgumentException(CacheBuilderSpec.format("key %s value set to %s, must be integer", str, str2), e);
}
} else {
StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 21);
sb.append("value of key ");
sb.append(str);
sb.append(" omitted");
throw new IllegalArgumentException(sb.toString());
}
}
}
static class InitialCapacityParser extends IntegerParser {
InitialCapacityParser() {
}
/* access modifiers changed from: protected */
public void parseInteger(CacheBuilderSpec cacheBuilderSpec, int i) {
Preconditions.checkArgument(cacheBuilderSpec.initialCapacity == null, "initial capacity was already set to ", (Object) cacheBuilderSpec.initialCapacity);
cacheBuilderSpec.initialCapacity = Integer.valueOf(i);
}
}
static class MaximumSizeParser extends LongParser {
MaximumSizeParser() {
}
/* access modifiers changed from: protected */
public void parseLong(CacheBuilderSpec cacheBuilderSpec, long j) {
boolean z = true;
Preconditions.checkArgument(cacheBuilderSpec.maximumSize == null, "maximum size was already set to ", (Object) cacheBuilderSpec.maximumSize);
if (cacheBuilderSpec.maximumWeight != null) {
z = false;
}
Preconditions.checkArgument(z, "maximum weight was already set to ", (Object) cacheBuilderSpec.maximumWeight);
cacheBuilderSpec.maximumSize = Long.valueOf(j);
}
}
static class MaximumWeightParser extends LongParser {
MaximumWeightParser() {
}
/* access modifiers changed from: protected */
public void parseLong(CacheBuilderSpec cacheBuilderSpec, long j) {
boolean z = true;
Preconditions.checkArgument(cacheBuilderSpec.maximumWeight == null, "maximum weight was already set to ", (Object) cacheBuilderSpec.maximumWeight);
if (cacheBuilderSpec.maximumSize != null) {
z = false;
}
Preconditions.checkArgument(z, "maximum size was already set to ", (Object) cacheBuilderSpec.maximumSize);
cacheBuilderSpec.maximumWeight = Long.valueOf(j);
}
}
static class ConcurrencyLevelParser extends IntegerParser {
ConcurrencyLevelParser() {
}
/* access modifiers changed from: protected */
public void parseInteger(CacheBuilderSpec cacheBuilderSpec, int i) {
Preconditions.checkArgument(cacheBuilderSpec.concurrencyLevel == null, "concurrency level was already set to ", (Object) cacheBuilderSpec.concurrencyLevel);
cacheBuilderSpec.concurrencyLevel = Integer.valueOf(i);
}
}
static class KeyStrengthParser implements ValueParser {
private final LocalCache.Strength strength;
public KeyStrengthParser(LocalCache.Strength strength2) {
this.strength = strength2;
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, @CheckForNull String str2) {
boolean z = true;
Preconditions.checkArgument(str2 == null, "key %s does not take values", (Object) str);
if (cacheBuilderSpec.keyStrength != null) {
z = false;
}
Preconditions.checkArgument(z, "%s was already set to %s", (Object) str, (Object) cacheBuilderSpec.keyStrength);
cacheBuilderSpec.keyStrength = this.strength;
}
}
static class ValueStrengthParser implements ValueParser {
private final LocalCache.Strength strength;
public ValueStrengthParser(LocalCache.Strength strength2) {
this.strength = strength2;
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, @CheckForNull String str2) {
boolean z = true;
Preconditions.checkArgument(str2 == null, "key %s does not take values", (Object) str);
if (cacheBuilderSpec.valueStrength != null) {
z = false;
}
Preconditions.checkArgument(z, "%s was already set to %s", (Object) str, (Object) cacheBuilderSpec.valueStrength);
cacheBuilderSpec.valueStrength = this.strength;
}
}
static class RecordStatsParser implements ValueParser {
RecordStatsParser() {
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, @CheckForNull String str2) {
boolean z = false;
Preconditions.checkArgument(str2 == null, "recordStats does not take values");
if (cacheBuilderSpec.recordStats == null) {
z = true;
}
Preconditions.checkArgument(z, "recordStats already set");
cacheBuilderSpec.recordStats = true;
}
}
static abstract class DurationParser implements ValueParser {
/* access modifiers changed from: protected */
public abstract void parseDuration(CacheBuilderSpec cacheBuilderSpec, long j, TimeUnit timeUnit);
DurationParser() {
}
public void parse(CacheBuilderSpec cacheBuilderSpec, String str, @CheckForNull String str2) {
TimeUnit timeUnit;
if (!Strings.isNullOrEmpty(str2)) {
try {
char charAt = str2.charAt(str2.length() - 1);
if (charAt == 'd') {
timeUnit = TimeUnit.DAYS;
} else if (charAt == 'h') {
timeUnit = TimeUnit.HOURS;
} else if (charAt == 'm') {
timeUnit = TimeUnit.MINUTES;
} else if (charAt == 's') {
timeUnit = TimeUnit.SECONDS;
} else {
throw new IllegalArgumentException(CacheBuilderSpec.format("key %s invalid unit: was %s, must end with one of [dhms]", str, str2));
}
parseDuration(cacheBuilderSpec, Long.parseLong(str2.substring(0, str2.length() - 1)), timeUnit);
} catch (NumberFormatException unused) {
throw new IllegalArgumentException(CacheBuilderSpec.format("key %s value set to %s, must be integer", str, str2));
}
} else {
StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 21);
sb.append("value of key ");
sb.append(str);
sb.append(" omitted");
throw new IllegalArgumentException(sb.toString());
}
}
}
static class AccessDurationParser extends DurationParser {
AccessDurationParser() {
}
/* access modifiers changed from: protected */
public void parseDuration(CacheBuilderSpec cacheBuilderSpec, long j, TimeUnit timeUnit) {
Preconditions.checkArgument(cacheBuilderSpec.accessExpirationTimeUnit == null, "expireAfterAccess already set");
cacheBuilderSpec.accessExpirationDuration = j;
cacheBuilderSpec.accessExpirationTimeUnit = timeUnit;
}
}
static class WriteDurationParser extends DurationParser {
WriteDurationParser() {
}
/* access modifiers changed from: protected */
public void parseDuration(CacheBuilderSpec cacheBuilderSpec, long j, TimeUnit timeUnit) {
Preconditions.checkArgument(cacheBuilderSpec.writeExpirationTimeUnit == null, "expireAfterWrite already set");
cacheBuilderSpec.writeExpirationDuration = j;
cacheBuilderSpec.writeExpirationTimeUnit = timeUnit;
}
}
static class RefreshDurationParser extends DurationParser {
RefreshDurationParser() {
}
/* access modifiers changed from: protected */
public void parseDuration(CacheBuilderSpec cacheBuilderSpec, long j, TimeUnit timeUnit) {
Preconditions.checkArgument(cacheBuilderSpec.refreshTimeUnit == null, "refreshAfterWrite already set");
cacheBuilderSpec.refreshDuration = j;
cacheBuilderSpec.refreshTimeUnit = timeUnit;
}
}
/* access modifiers changed from: private */
public static String format(String str, Object... objArr) {
return String.format(Locale.ROOT, str, objArr);
}
}
Download file