CrackMe.apk
Download file
package kotlin.reflect.jvm.internal.impl.storage;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.reflect.jvm.internal.impl.utils.ExceptionUtilsKt;
import kotlin.reflect.jvm.internal.impl.utils.WrappedValues;
import kotlin.text.StringsKt;
public class LockBasedStorageManager implements StorageManager {
static final /* synthetic */ boolean $assertionsDisabled = false;
public static final StorageManager NO_LOCKS = new LockBasedStorageManager("NO_LOCKS", ExceptionHandlingStrategy.THROW, EmptySimpleLock.INSTANCE) {
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 1 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
Object[] objArr = new Object[(i != 1 ? 3 : 2)];
if (i != 1) {
objArr[0] = "source";
} else {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$1";
}
if (i != 1) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$1";
} else {
objArr[1] = "recursionDetectedDefault";
}
if (i != 1) {
objArr[2] = "recursionDetectedDefault";
}
String format = String.format(str, objArr);
throw (i != 1 ? new IllegalArgumentException(format) : new IllegalStateException(format));
}
/* access modifiers changed from: protected */
public <K, V> RecursionDetectedResult<V> recursionDetectedDefault(String str, K k) {
if (str == null) {
$$$reportNull$$$0(0);
}
RecursionDetectedResult<V> fallThrough = RecursionDetectedResult.fallThrough();
if (fallThrough == null) {
$$$reportNull$$$0(1);
}
return fallThrough;
}
};
private static final String PACKAGE_NAME = StringsKt.substringBeforeLast(LockBasedStorageManager.class.getCanonicalName(), ".", "");
private final String debugText;
/* access modifiers changed from: private */
public final ExceptionHandlingStrategy exceptionHandlingStrategy;
protected final SimpleLock lock;
public interface ExceptionHandlingStrategy {
public static final ExceptionHandlingStrategy THROW = new ExceptionHandlingStrategy() {
private static /* synthetic */ void $$$reportNull$$$0(int i) {
throw new IllegalArgumentException(String.format("Argument for @NotNull parameter '%s' of %s.%s must not be null", new Object[]{"throwable", "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$ExceptionHandlingStrategy$1", "handleException"}));
}
public RuntimeException handleException(Throwable th) {
if (th == null) {
$$$reportNull$$$0(0);
}
throw ExceptionUtilsKt.rethrow(th);
}
};
RuntimeException handleException(Throwable th);
}
private enum NotValue {
NOT_COMPUTED,
COMPUTING,
RECURSION_WAS_DETECTED
}
/* JADX WARNING: Removed duplicated region for block: B:43:0x0085 */
/* JADX WARNING: Removed duplicated region for block: B:44:0x008a */
/* JADX WARNING: Removed duplicated region for block: B:45:0x008d */
/* JADX WARNING: Removed duplicated region for block: B:46:0x0092 */
/* JADX WARNING: Removed duplicated region for block: B:47:0x0095 */
/* JADX WARNING: Removed duplicated region for block: B:48:0x009a */
/* JADX WARNING: Removed duplicated region for block: B:49:0x009f */
/* JADX WARNING: Removed duplicated region for block: B:50:0x00a4 */
/* JADX WARNING: Removed duplicated region for block: B:51:0x00a9 */
/* JADX WARNING: Removed duplicated region for block: B:52:0x00ae */
/* JADX WARNING: Removed duplicated region for block: B:53:0x00b3 */
/* JADX WARNING: Removed duplicated region for block: B:54:0x00b6 */
/* JADX WARNING: Removed duplicated region for block: B:55:0x00b9 */
/* JADX WARNING: Removed duplicated region for block: B:56:0x00be */
/* Code decompiled incorrectly, please refer to instructions dump. */
private static /* synthetic */ void $$$reportNull$$$0(int r13) {
/*
r0 = 37
r1 = 20
r2 = 13
r3 = 10
if (r13 == r3) goto L_0x0013
if (r13 == r2) goto L_0x0013
if (r13 == r1) goto L_0x0013
if (r13 == r0) goto L_0x0013
java.lang.String r4 = "Argument for @NotNull parameter '%s' of %s.%s must not be null"
goto L_0x0015
L_0x0013:
java.lang.String r4 = "@NotNull method %s.%s must not return null"
L_0x0015:
r5 = 3
r6 = 2
if (r13 == r3) goto L_0x0021
if (r13 == r2) goto L_0x0021
if (r13 == r1) goto L_0x0021
if (r13 == r0) goto L_0x0021
r7 = 3
goto L_0x0022
L_0x0021:
r7 = 2
L_0x0022:
java.lang.Object[] r7 = new java.lang.Object[r7]
java.lang.String r8 = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager"
java.lang.String r9 = "compute"
r10 = 1
r11 = 0
if (r13 == r10) goto L_0x0065
if (r13 == r5) goto L_0x0065
r5 = 5
if (r13 == r5) goto L_0x0065
r5 = 6
if (r13 == r5) goto L_0x0060
switch(r13) {
case 8: goto L_0x0065;
case 9: goto L_0x005d;
case 10: goto L_0x005a;
case 11: goto L_0x005d;
case 12: goto L_0x0055;
case 13: goto L_0x005a;
case 14: goto L_0x005d;
case 15: goto L_0x0050;
case 16: goto L_0x005d;
case 17: goto L_0x0055;
case 18: goto L_0x0050;
case 19: goto L_0x005d;
case 20: goto L_0x005a;
case 21: goto L_0x005d;
case 22: goto L_0x0050;
case 23: goto L_0x004b;
case 24: goto L_0x004b;
case 25: goto L_0x0055;
case 26: goto L_0x004b;
case 27: goto L_0x0055;
case 28: goto L_0x004b;
case 29: goto L_0x0046;
case 30: goto L_0x004b;
case 31: goto L_0x004b;
case 32: goto L_0x004b;
case 33: goto L_0x0046;
case 34: goto L_0x004b;
case 35: goto L_0x0041;
case 36: goto L_0x003c;
case 37: goto L_0x005a;
default: goto L_0x0037;
}
L_0x0037:
java.lang.String r5 = "debugText"
r7[r11] = r5
goto L_0x0069
L_0x003c:
java.lang.String r5 = "throwable"
r7[r11] = r5
goto L_0x0069
L_0x0041:
java.lang.String r5 = "source"
r7[r11] = r5
goto L_0x0069
L_0x0046:
java.lang.String r5 = "postCompute"
r7[r11] = r5
goto L_0x0069
L_0x004b:
java.lang.String r5 = "computable"
r7[r11] = r5
goto L_0x0069
L_0x0050:
java.lang.String r5 = "map"
r7[r11] = r5
goto L_0x0069
L_0x0055:
java.lang.String r5 = "onRecursiveCall"
r7[r11] = r5
goto L_0x0069
L_0x005a:
r7[r11] = r8
goto L_0x0069
L_0x005d:
r7[r11] = r9
goto L_0x0069
L_0x0060:
java.lang.String r5 = "lock"
r7[r11] = r5
goto L_0x0069
L_0x0065:
java.lang.String r5 = "exceptionHandlingStrategy"
r7[r11] = r5
L_0x0069:
java.lang.String r5 = "sanitizeStackTrace"
java.lang.String r11 = "createMemoizedFunctionWithNullableValues"
java.lang.String r12 = "createMemoizedFunction"
if (r13 == r3) goto L_0x0080
if (r13 == r2) goto L_0x0080
if (r13 == r1) goto L_0x007d
if (r13 == r0) goto L_0x007a
r7[r10] = r8
goto L_0x0082
L_0x007a:
r7[r10] = r5
goto L_0x0082
L_0x007d:
r7[r10] = r11
goto L_0x0082
L_0x0080:
r7[r10] = r12
L_0x0082:
switch(r13) {
case 4: goto L_0x00be;
case 5: goto L_0x00be;
case 6: goto L_0x00be;
case 7: goto L_0x00b9;
case 8: goto L_0x00b9;
case 9: goto L_0x00b6;
case 10: goto L_0x00c2;
case 11: goto L_0x00b6;
case 12: goto L_0x00b6;
case 13: goto L_0x00c2;
case 14: goto L_0x00b6;
case 15: goto L_0x00b6;
case 16: goto L_0x00b6;
case 17: goto L_0x00b6;
case 18: goto L_0x00b6;
case 19: goto L_0x00b3;
case 20: goto L_0x00c2;
case 21: goto L_0x00b3;
case 22: goto L_0x00b3;
case 23: goto L_0x00ae;
case 24: goto L_0x00ae;
case 25: goto L_0x00ae;
case 26: goto L_0x00a9;
case 27: goto L_0x00a9;
case 28: goto L_0x00a4;
case 29: goto L_0x00a4;
case 30: goto L_0x009f;
case 31: goto L_0x009a;
case 32: goto L_0x0095;
case 33: goto L_0x0095;
case 34: goto L_0x0092;
case 35: goto L_0x008d;
case 36: goto L_0x008a;
case 37: goto L_0x00c2;
default: goto L_0x0085;
}
L_0x0085:
java.lang.String r5 = "createWithExceptionHandling"
r7[r6] = r5
goto L_0x00c2
L_0x008a:
r7[r6] = r5
goto L_0x00c2
L_0x008d:
java.lang.String r5 = "recursionDetectedDefault"
r7[r6] = r5
goto L_0x00c2
L_0x0092:
r7[r6] = r9
goto L_0x00c2
L_0x0095:
java.lang.String r5 = "createNullableLazyValueWithPostCompute"
r7[r6] = r5
goto L_0x00c2
L_0x009a:
java.lang.String r5 = "createRecursionTolerantNullableLazyValue"
r7[r6] = r5
goto L_0x00c2
L_0x009f:
java.lang.String r5 = "createNullableLazyValue"
r7[r6] = r5
goto L_0x00c2
L_0x00a4:
java.lang.String r5 = "createLazyValueWithPostCompute"
r7[r6] = r5
goto L_0x00c2
L_0x00a9:
java.lang.String r5 = "createRecursionTolerantLazyValue"
r7[r6] = r5
goto L_0x00c2
L_0x00ae:
java.lang.String r5 = "createLazyValue"
r7[r6] = r5
goto L_0x00c2
L_0x00b3:
r7[r6] = r11
goto L_0x00c2
L_0x00b6:
r7[r6] = r12
goto L_0x00c2
L_0x00b9:
java.lang.String r5 = "replaceExceptionHandling"
r7[r6] = r5
goto L_0x00c2
L_0x00be:
java.lang.String r5 = "<init>"
r7[r6] = r5
L_0x00c2:
java.lang.String r4 = java.lang.String.format(r4, r7)
if (r13 == r3) goto L_0x00d4
if (r13 == r2) goto L_0x00d4
if (r13 == r1) goto L_0x00d4
if (r13 == r0) goto L_0x00d4
java.lang.IllegalArgumentException r13 = new java.lang.IllegalArgumentException
r13.<init>(r4)
goto L_0x00d9
L_0x00d4:
java.lang.IllegalStateException r13 = new java.lang.IllegalStateException
r13.<init>(r4)
L_0x00d9:
throw r13
*/
throw new UnsupportedOperationException("Method not decompiled: kotlin.reflect.jvm.internal.impl.storage.LockBasedStorageManager.$$$reportNull$$$0(int):void");
}
private LockBasedStorageManager(String str, ExceptionHandlingStrategy exceptionHandlingStrategy2, SimpleLock simpleLock) {
if (str == null) {
$$$reportNull$$$0(4);
}
if (exceptionHandlingStrategy2 == null) {
$$$reportNull$$$0(5);
}
if (simpleLock == null) {
$$$reportNull$$$0(6);
}
this.lock = simpleLock;
this.exceptionHandlingStrategy = exceptionHandlingStrategy2;
this.debugText = str;
}
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
public LockBasedStorageManager(String str) {
this(str, (Runnable) null, (Function1<InterruptedException, Unit>) null);
Runnable runnable = null;
}
public LockBasedStorageManager(String str, Runnable runnable, Function1<InterruptedException, Unit> function1) {
this(str, ExceptionHandlingStrategy.THROW, (SimpleLock) SimpleLock.Companion.simpleLock(runnable, function1));
}
public String toString() {
return getClass().getSimpleName() + "@" + Integer.toHexString(hashCode()) + " (" + this.debugText + ")";
}
public <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(Function1<? super K, ? extends V> function1) {
if (function1 == null) {
$$$reportNull$$$0(9);
}
MemoizedFunctionToNotNull<K, V> createMemoizedFunction = createMemoizedFunction(function1, createConcurrentHashMap());
if (createMemoizedFunction == null) {
$$$reportNull$$$0(10);
}
return createMemoizedFunction;
}
public <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(Function1<? super K, ? extends V> function1, ConcurrentMap<K, Object> concurrentMap) {
if (function1 == null) {
$$$reportNull$$$0(14);
}
if (concurrentMap == null) {
$$$reportNull$$$0(15);
}
return new MapBasedMemoizedFunctionToNotNull(this, concurrentMap, function1);
}
public <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(Function1<? super K, ? extends V> function1) {
if (function1 == null) {
$$$reportNull$$$0(19);
}
MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues = createMemoizedFunctionWithNullableValues(function1, createConcurrentHashMap());
if (createMemoizedFunctionWithNullableValues == null) {
$$$reportNull$$$0(20);
}
return createMemoizedFunctionWithNullableValues;
}
public <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(Function1<? super K, ? extends V> function1, ConcurrentMap<K, Object> concurrentMap) {
if (function1 == null) {
$$$reportNull$$$0(21);
}
if (concurrentMap == null) {
$$$reportNull$$$0(22);
}
return new MapBasedMemoizedFunction(this, concurrentMap, function1);
}
public <T> NotNullLazyValue<T> createLazyValue(Function0<? extends T> function0) {
if (function0 == null) {
$$$reportNull$$$0(23);
}
return new LockBasedNotNullLazyValue(this, function0);
}
public <T> NotNullLazyValue<T> createRecursionTolerantLazyValue(Function0<? extends T> function0, final T t) {
if (function0 == null) {
$$$reportNull$$$0(26);
}
if (t == null) {
$$$reportNull$$$0(27);
}
return new LockBasedNotNullLazyValue<T>(this, function0) {
private static /* synthetic */ void $$$reportNull$$$0(int i) {
throw new IllegalStateException(String.format("@NotNull method %s.%s must not return null", new Object[]{"kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$4", "recursionDetected"}));
}
/* access modifiers changed from: protected */
public RecursionDetectedResult<T> recursionDetected(boolean z) {
RecursionDetectedResult<T> value = RecursionDetectedResult.value(t);
if (value == null) {
$$$reportNull$$$0(0);
}
return value;
}
};
}
public <T> NotNullLazyValue<T> createLazyValueWithPostCompute(Function0<? extends T> function0, Function1<? super Boolean, ? extends T> function1, Function1<? super T, Unit> function12) {
if (function0 == null) {
$$$reportNull$$$0(28);
}
if (function12 == null) {
$$$reportNull$$$0(29);
}
final Function1<? super Boolean, ? extends T> function13 = function1;
final Function1<? super T, Unit> function14 = function12;
return new LockBasedNotNullLazyValueWithPostCompute<T>(this, function0) {
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 2 ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
Object[] objArr = new Object[(i != 2 ? 2 : 3)];
if (i != 2) {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$5";
} else {
objArr[0] = "value";
}
if (i != 2) {
objArr[1] = "recursionDetected";
} else {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$5";
}
if (i == 2) {
objArr[2] = "doPostCompute";
}
String format = String.format(str, objArr);
throw (i != 2 ? new IllegalStateException(format) : new IllegalArgumentException(format));
}
/* access modifiers changed from: protected */
public RecursionDetectedResult<T> recursionDetected(boolean z) {
Function1 function1 = function13;
if (function1 == null) {
RecursionDetectedResult<T> recursionDetected = super.recursionDetected(z);
if (recursionDetected == null) {
$$$reportNull$$$0(0);
}
return recursionDetected;
}
RecursionDetectedResult<T> value = RecursionDetectedResult.value(function1.invoke(Boolean.valueOf(z)));
if (value == null) {
$$$reportNull$$$0(1);
}
return value;
}
/* access modifiers changed from: protected */
public void doPostCompute(T t) {
if (t == null) {
$$$reportNull$$$0(2);
}
function14.invoke(t);
}
};
}
public <T> NullableLazyValue<T> createNullableLazyValue(Function0<? extends T> function0) {
if (function0 == null) {
$$$reportNull$$$0(30);
}
return new LockBasedLazyValue(this, function0);
}
public <T> T compute(Function0<? extends T> function0) {
if (function0 == null) {
$$$reportNull$$$0(34);
}
this.lock.lock();
try {
T invoke = function0.invoke();
this.lock.unlock();
return invoke;
} catch (Throwable th) {
this.lock.unlock();
throw th;
}
}
private static <K> ConcurrentMap<K, Object> createConcurrentHashMap() {
return new ConcurrentHashMap(3, 1.0f, 2);
}
/* access modifiers changed from: protected */
public <K, V> RecursionDetectedResult<V> recursionDetectedDefault(String str, K k) {
String str2;
if (str == null) {
$$$reportNull$$$0(35);
}
StringBuilder sb = new StringBuilder();
sb.append("Recursion detected ");
sb.append(str);
if (k == null) {
str2 = "";
} else {
str2 = "on input: " + k;
}
sb.append(str2);
sb.append(" under ");
sb.append(this);
throw ((AssertionError) sanitizeStackTrace(new AssertionError(sb.toString())));
}
private static class RecursionDetectedResult<T> {
static final /* synthetic */ boolean $assertionsDisabled = false;
private final boolean fallThrough;
private final T value;
static {
Class<LockBasedStorageManager> cls = LockBasedStorageManager.class;
}
public static <T> RecursionDetectedResult<T> value(T t) {
return new RecursionDetectedResult<>(t, false);
}
public static <T> RecursionDetectedResult<T> fallThrough() {
return new RecursionDetectedResult<>((Object) null, true);
}
private RecursionDetectedResult(T t, boolean z) {
this.value = t;
this.fallThrough = z;
}
public T getValue() {
return this.value;
}
public boolean isFallThrough() {
return this.fallThrough;
}
public String toString() {
return isFallThrough() ? "FALL_THROUGH" : String.valueOf(this.value);
}
}
private static class LockBasedLazyValue<T> implements NullableLazyValue<T> {
private final Function0<? extends T> computable;
private final LockBasedStorageManager storageManager;
private volatile Object value;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = (i == 2 || i == 3) ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
Object[] objArr = new Object[((i == 2 || i == 3) ? 2 : 3)];
if (i == 1) {
objArr[0] = "computable";
} else if (i == 2 || i == 3) {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedLazyValue";
} else {
objArr[0] = "storageManager";
}
if (i == 2) {
objArr[1] = "recursionDetected";
} else if (i != 3) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedLazyValue";
} else {
objArr[1] = "renderDebugInformation";
}
if (!(i == 2 || i == 3)) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw ((i == 2 || i == 3) ? new IllegalStateException(format) : new IllegalArgumentException(format));
}
/* access modifiers changed from: protected */
public void postCompute(T t) {
}
public LockBasedLazyValue(LockBasedStorageManager lockBasedStorageManager, Function0<? extends T> function0) {
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (function0 == null) {
$$$reportNull$$$0(1);
}
this.value = NotValue.NOT_COMPUTED;
this.storageManager = lockBasedStorageManager;
this.computable = function0;
}
public boolean isComputed() {
return (this.value == NotValue.NOT_COMPUTED || this.value == NotValue.COMPUTING) ? false : true;
}
public T invoke() {
T invoke;
Object obj = this.value;
if (!(obj instanceof NotValue)) {
return WrappedValues.unescapeThrowable(obj);
}
this.storageManager.lock.lock();
try {
Object obj2 = this.value;
if (!(obj2 instanceof NotValue)) {
invoke = WrappedValues.unescapeThrowable(obj2);
} else {
if (obj2 == NotValue.COMPUTING) {
this.value = NotValue.RECURSION_WAS_DETECTED;
RecursionDetectedResult recursionDetected = recursionDetected(true);
if (!recursionDetected.isFallThrough()) {
invoke = recursionDetected.getValue();
}
}
if (obj2 == NotValue.RECURSION_WAS_DETECTED) {
RecursionDetectedResult recursionDetected2 = recursionDetected(false);
if (!recursionDetected2.isFallThrough()) {
invoke = recursionDetected2.getValue();
}
}
this.value = NotValue.COMPUTING;
invoke = this.computable.invoke();
postCompute(invoke);
this.value = invoke;
}
this.storageManager.lock.unlock();
return invoke;
} catch (Throwable th) {
this.storageManager.lock.unlock();
throw th;
}
}
/* access modifiers changed from: protected */
public RecursionDetectedResult<T> recursionDetected(boolean z) {
RecursionDetectedResult<T> recursionDetectedDefault = this.storageManager.recursionDetectedDefault("in a lazy value", null);
if (recursionDetectedDefault == null) {
$$$reportNull$$$0(2);
}
return recursionDetectedDefault;
}
}
private static abstract class LockBasedLazyValueWithPostCompute<T> extends LockBasedLazyValue<T> {
private volatile SingleThreadValue<T> valuePostCompute;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
Object[] objArr = new Object[3];
if (i != 1) {
objArr[0] = "storageManager";
} else {
objArr[0] = "computable";
}
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedLazyValueWithPostCompute";
objArr[2] = "<init>";
throw new IllegalArgumentException(String.format("Argument for @NotNull parameter '%s' of %s.%s must not be null", objArr));
}
/* access modifiers changed from: protected */
public abstract void doPostCompute(T t);
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
public LockBasedLazyValueWithPostCompute(LockBasedStorageManager lockBasedStorageManager, Function0<? extends T> function0) {
super(lockBasedStorageManager, function0);
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (function0 == null) {
$$$reportNull$$$0(1);
}
this.valuePostCompute = null;
}
public T invoke() {
SingleThreadValue<T> singleThreadValue = this.valuePostCompute;
if (singleThreadValue == null || !singleThreadValue.hasValue()) {
return super.invoke();
}
return singleThreadValue.getValue();
}
/* access modifiers changed from: protected */
public final void postCompute(T t) {
this.valuePostCompute = new SingleThreadValue<>(t);
try {
doPostCompute(t);
} finally {
this.valuePostCompute = null;
}
}
}
private static abstract class LockBasedNotNullLazyValueWithPostCompute<T> extends LockBasedLazyValueWithPostCompute<T> implements NotNullLazyValue<T> {
static final /* synthetic */ boolean $assertionsDisabled = false;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 2 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
Object[] objArr = new Object[(i != 2 ? 3 : 2)];
if (i == 1) {
objArr[0] = "computable";
} else if (i != 2) {
objArr[0] = "storageManager";
} else {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedNotNullLazyValueWithPostCompute";
}
if (i != 2) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedNotNullLazyValueWithPostCompute";
} else {
objArr[1] = "invoke";
}
if (i != 2) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw (i != 2 ? new IllegalArgumentException(format) : new IllegalStateException(format));
}
static {
Class<LockBasedStorageManager> cls = LockBasedStorageManager.class;
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
public LockBasedNotNullLazyValueWithPostCompute(LockBasedStorageManager lockBasedStorageManager, Function0<? extends T> function0) {
super(lockBasedStorageManager, function0);
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (function0 == null) {
$$$reportNull$$$0(1);
}
}
public T invoke() {
T invoke = super.invoke();
if (invoke == null) {
$$$reportNull$$$0(2);
}
return invoke;
}
}
private static class LockBasedNotNullLazyValue<T> extends LockBasedLazyValue<T> implements NotNullLazyValue<T> {
static final /* synthetic */ boolean $assertionsDisabled = false;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 2 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
Object[] objArr = new Object[(i != 2 ? 3 : 2)];
if (i == 1) {
objArr[0] = "computable";
} else if (i != 2) {
objArr[0] = "storageManager";
} else {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedNotNullLazyValue";
}
if (i != 2) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$LockBasedNotNullLazyValue";
} else {
objArr[1] = "invoke";
}
if (i != 2) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw (i != 2 ? new IllegalArgumentException(format) : new IllegalStateException(format));
}
static {
Class<LockBasedStorageManager> cls = LockBasedStorageManager.class;
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
public LockBasedNotNullLazyValue(LockBasedStorageManager lockBasedStorageManager, Function0<? extends T> function0) {
super(lockBasedStorageManager, function0);
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (function0 == null) {
$$$reportNull$$$0(1);
}
}
public T invoke() {
T invoke = super.invoke();
if (invoke == null) {
$$$reportNull$$$0(2);
}
return invoke;
}
}
private static class MapBasedMemoizedFunction<K, V> implements MemoizedFunctionToNullable<K, V> {
private final ConcurrentMap<K, Object> cache;
private final Function1<? super K, ? extends V> compute;
private final LockBasedStorageManager storageManager;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = (i == 3 || i == 4) ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
Object[] objArr = new Object[((i == 3 || i == 4) ? 2 : 3)];
if (i == 1) {
objArr[0] = "map";
} else if (i == 2) {
objArr[0] = "compute";
} else if (i == 3 || i == 4) {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$MapBasedMemoizedFunction";
} else {
objArr[0] = "storageManager";
}
if (i == 3) {
objArr[1] = "recursionDetected";
} else if (i != 4) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$MapBasedMemoizedFunction";
} else {
objArr[1] = "raceCondition";
}
if (!(i == 3 || i == 4)) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw ((i == 3 || i == 4) ? new IllegalStateException(format) : new IllegalArgumentException(format));
}
public MapBasedMemoizedFunction(LockBasedStorageManager lockBasedStorageManager, ConcurrentMap<K, Object> concurrentMap, Function1<? super K, ? extends V> function1) {
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (concurrentMap == null) {
$$$reportNull$$$0(1);
}
if (function1 == null) {
$$$reportNull$$$0(2);
}
this.storageManager = lockBasedStorageManager;
this.cache = concurrentMap;
this.compute = function1;
}
public V invoke(K k) {
V unescapeExceptionOrNull;
Object obj = this.cache.get(k);
if (obj != null && obj != NotValue.COMPUTING) {
return WrappedValues.unescapeExceptionOrNull(obj);
}
this.storageManager.lock.lock();
try {
Object obj2 = this.cache.get(k);
if (obj2 == NotValue.COMPUTING) {
obj2 = NotValue.RECURSION_WAS_DETECTED;
RecursionDetectedResult recursionDetected = recursionDetected(k, true);
if (!recursionDetected.isFallThrough()) {
unescapeExceptionOrNull = recursionDetected.getValue();
this.storageManager.lock.unlock();
return unescapeExceptionOrNull;
}
}
if (obj2 == NotValue.RECURSION_WAS_DETECTED) {
RecursionDetectedResult recursionDetected2 = recursionDetected(k, false);
if (!recursionDetected2.isFallThrough()) {
unescapeExceptionOrNull = recursionDetected2.getValue();
this.storageManager.lock.unlock();
return unescapeExceptionOrNull;
}
}
if (obj2 != null) {
unescapeExceptionOrNull = WrappedValues.unescapeExceptionOrNull(obj2);
this.storageManager.lock.unlock();
return unescapeExceptionOrNull;
}
this.cache.put(k, NotValue.COMPUTING);
V invoke = this.compute.invoke(k);
Object put = this.cache.put(k, WrappedValues.escapeNull(invoke));
if (put == NotValue.COMPUTING) {
this.storageManager.lock.unlock();
return invoke;
}
throw raceCondition(k, put);
} catch (Throwable th) {
this.storageManager.lock.unlock();
throw th;
}
}
/* access modifiers changed from: protected */
public RecursionDetectedResult<V> recursionDetected(K k, boolean z) {
RecursionDetectedResult<V> recursionDetectedDefault = this.storageManager.recursionDetectedDefault("", k);
if (recursionDetectedDefault == null) {
$$$reportNull$$$0(3);
}
return recursionDetectedDefault;
}
private AssertionError raceCondition(K k, Object obj) {
AssertionError assertionError = (AssertionError) LockBasedStorageManager.sanitizeStackTrace(new AssertionError("Race condition detected on input " + k + ". Old value is " + obj + " under " + this.storageManager));
if (assertionError == null) {
$$$reportNull$$$0(4);
}
return assertionError;
}
public boolean isComputed(K k) {
Object obj = this.cache.get(k);
return (obj == null || obj == NotValue.COMPUTING) ? false : true;
}
/* access modifiers changed from: protected */
public LockBasedStorageManager getStorageManager() {
return this.storageManager;
}
}
private static class MapBasedMemoizedFunctionToNotNull<K, V> extends MapBasedMemoizedFunction<K, V> implements MemoizedFunctionToNotNull<K, V> {
static final /* synthetic */ boolean $assertionsDisabled = false;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 3 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
Object[] objArr = new Object[(i != 3 ? 3 : 2)];
if (i == 1) {
objArr[0] = "map";
} else if (i == 2) {
objArr[0] = "compute";
} else if (i != 3) {
objArr[0] = "storageManager";
} else {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$MapBasedMemoizedFunctionToNotNull";
}
if (i != 3) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$MapBasedMemoizedFunctionToNotNull";
} else {
objArr[1] = "invoke";
}
if (i != 3) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw (i != 3 ? new IllegalArgumentException(format) : new IllegalStateException(format));
}
static {
Class<LockBasedStorageManager> cls = LockBasedStorageManager.class;
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
public MapBasedMemoizedFunctionToNotNull(LockBasedStorageManager lockBasedStorageManager, ConcurrentMap<K, Object> concurrentMap, Function1<? super K, ? extends V> function1) {
super(lockBasedStorageManager, concurrentMap, function1);
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (concurrentMap == null) {
$$$reportNull$$$0(1);
}
if (function1 == null) {
$$$reportNull$$$0(2);
}
}
public V invoke(K k) {
V invoke = super.invoke(k);
if (invoke == null) {
$$$reportNull$$$0(3);
}
return invoke;
}
}
/* access modifiers changed from: private */
public static <T extends Throwable> T sanitizeStackTrace(T t) {
if (t == null) {
$$$reportNull$$$0(36);
}
StackTraceElement[] stackTrace = t.getStackTrace();
int length = stackTrace.length;
int i = -1;
int i2 = 0;
while (true) {
if (i2 >= length) {
break;
} else if (!stackTrace[i2].getClassName().startsWith(PACKAGE_NAME)) {
i = i2;
break;
} else {
i2++;
}
}
List subList = Arrays.asList(stackTrace).subList(i, length);
t.setStackTrace((StackTraceElement[]) subList.toArray(new StackTraceElement[subList.size()]));
if (t == null) {
$$$reportNull$$$0(37);
}
return t;
}
public <K, V> CacheWithNullableValues<K, V> createCacheWithNullableValues() {
return new CacheWithNullableValuesBasedOnMemoizedFunction(createConcurrentHashMap());
}
private static class CacheWithNullableValuesBasedOnMemoizedFunction<K, V> extends MapBasedMemoizedFunction<KeyWithComputation<K, V>, V> implements CacheWithNullableValues<K, V> {
private static /* synthetic */ void $$$reportNull$$$0(int i) {
Object[] objArr = new Object[3];
if (i == 1) {
objArr[0] = "map";
} else if (i != 2) {
objArr[0] = "storageManager";
} else {
objArr[0] = "computation";
}
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$CacheWithNullableValuesBasedOnMemoizedFunction";
if (i != 2) {
objArr[2] = "<init>";
} else {
objArr[2] = "computeIfAbsent";
}
throw new IllegalArgumentException(String.format("Argument for @NotNull parameter '%s' of %s.%s must not be null", objArr));
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
private CacheWithNullableValuesBasedOnMemoizedFunction(LockBasedStorageManager lockBasedStorageManager, ConcurrentMap<KeyWithComputation<K, V>, Object> concurrentMap) {
super(lockBasedStorageManager, concurrentMap, new Function1<KeyWithComputation<K, V>, V>() {
public V invoke(KeyWithComputation<K, V> keyWithComputation) {
return keyWithComputation.computation.invoke();
}
});
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (concurrentMap == null) {
$$$reportNull$$$0(1);
}
}
public V computeIfAbsent(K k, Function0<? extends V> function0) {
if (function0 == null) {
$$$reportNull$$$0(2);
}
return invoke(new KeyWithComputation(k, function0));
}
}
public <K, V> CacheWithNotNullValues<K, V> createCacheWithNotNullValues() {
return new CacheWithNotNullValuesBasedOnMemoizedFunction(createConcurrentHashMap());
}
private static class CacheWithNotNullValuesBasedOnMemoizedFunction<K, V> extends CacheWithNullableValuesBasedOnMemoizedFunction<K, V> implements CacheWithNotNullValues<K, V> {
static final /* synthetic */ boolean $assertionsDisabled = false;
private static /* synthetic */ void $$$reportNull$$$0(int i) {
String str = i != 3 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
Object[] objArr = new Object[(i != 3 ? 3 : 2)];
if (i == 1) {
objArr[0] = "map";
} else if (i == 2) {
objArr[0] = "computation";
} else if (i != 3) {
objArr[0] = "storageManager";
} else {
objArr[0] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$CacheWithNotNullValuesBasedOnMemoizedFunction";
}
if (i != 3) {
objArr[1] = "kotlin/reflect/jvm/internal/impl/storage/LockBasedStorageManager$CacheWithNotNullValuesBasedOnMemoizedFunction";
} else {
objArr[1] = "computeIfAbsent";
}
if (i == 2) {
objArr[2] = "computeIfAbsent";
} else if (i != 3) {
objArr[2] = "<init>";
}
String format = String.format(str, objArr);
throw (i != 3 ? new IllegalArgumentException(format) : new IllegalStateException(format));
}
static {
Class<LockBasedStorageManager> cls = LockBasedStorageManager.class;
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
private CacheWithNotNullValuesBasedOnMemoizedFunction(LockBasedStorageManager lockBasedStorageManager, ConcurrentMap<KeyWithComputation<K, V>, Object> concurrentMap) {
super(concurrentMap);
if (lockBasedStorageManager == null) {
$$$reportNull$$$0(0);
}
if (concurrentMap == null) {
$$$reportNull$$$0(1);
}
}
public V computeIfAbsent(K k, Function0<? extends V> function0) {
if (function0 == null) {
$$$reportNull$$$0(2);
}
V computeIfAbsent = super.computeIfAbsent(k, function0);
if (computeIfAbsent == null) {
$$$reportNull$$$0(3);
}
return computeIfAbsent;
}
}
private static class KeyWithComputation<K, V> {
/* access modifiers changed from: private */
public final Function0<? extends V> computation;
private final K key;
public KeyWithComputation(K k, Function0<? extends V> function0) {
this.key = k;
this.computation = function0;
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
return obj != null && getClass() == obj.getClass() && this.key.equals(((KeyWithComputation) obj).key);
}
public int hashCode() {
return this.key.hashCode();
}
}
}
Download file