ADD week 5

2025-03-31 16:33:42 +02:00
parent 86f265f22d
commit bf645048e6
4927 changed files with 544053 additions and 0 deletions
--- a/02-Easy5/E5/sources/kotlin/jvm/internal/CallableReference.java
+++ b/02-Easy5/E5/sources/kotlin/jvm/internal/CallableReference.java
@@ -0,0 +1,148 @@
+package kotlin.jvm.internal;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Map;
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KDeclarationContainer;
+import kotlin.reflect.KParameter;
+import kotlin.reflect.KType;
+import kotlin.reflect.KTypeParameter;
+import kotlin.reflect.KVisibility;
+
+/* loaded from: classes.dex */
+public abstract class CallableReference implements KCallable, Serializable {
+    public static final Object NO_RECEIVER = NoReceiver.INSTANCE;
+    private final boolean isTopLevel;
+    private final String name;
+    private final Class owner;
+    protected final Object receiver;
+    private transient KCallable reflected;
+    private final String signature;
+
+    protected abstract KCallable computeReflected();
+
+    public Object getBoundReceiver() {
+        return this.receiver;
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public String getName() {
+        return this.name;
+    }
+
+    public String getSignature() {
+        return this.signature;
+    }
+
+    private static class NoReceiver implements Serializable {
+        private static final NoReceiver INSTANCE = new NoReceiver();
+
+        private Object readResolve() throws ObjectStreamException {
+            return INSTANCE;
+        }
+
+        private NoReceiver() {
+        }
+    }
+
+    public CallableReference() {
+        this(NO_RECEIVER);
+    }
+
+    protected CallableReference(Object obj) {
+        this(obj, null, null, null, false);
+    }
+
+    protected CallableReference(Object obj, Class cls, String str, String str2, boolean z) {
+        this.receiver = obj;
+        this.owner = cls;
+        this.name = str;
+        this.signature = str2;
+        this.isTopLevel = z;
+    }
+
+    public KCallable compute() {
+        KCallable kCallable = this.reflected;
+        if (kCallable != null) {
+            return kCallable;
+        }
+        KCallable computeReflected = computeReflected();
+        this.reflected = computeReflected;
+        return computeReflected;
+    }
+
+    protected KCallable getReflected() {
+        KCallable compute = compute();
+        if (compute != this) {
+            return compute;
+        }
+        throw new KotlinReflectionNotSupportedError();
+    }
+
+    public KDeclarationContainer getOwner() {
+        Class cls = this.owner;
+        if (cls == null) {
+            return null;
+        }
+        return this.isTopLevel ? Reflection.getOrCreateKotlinPackage(cls) : Reflection.getOrCreateKotlinClass(cls);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public List<KParameter> getParameters() {
+        return getReflected().getParameters();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public KType getReturnType() {
+        return getReflected().getReturnType();
+    }
+
+    @Override // kotlin.reflect.KAnnotatedElement
+    public List<Annotation> getAnnotations() {
+        return getReflected().getAnnotations();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public List<KTypeParameter> getTypeParameters() {
+        return getReflected().getTypeParameters();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public Object call(Object... objArr) {
+        return getReflected().call(objArr);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public Object callBy(Map map) {
+        return getReflected().callBy(map);
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public KVisibility getVisibility() {
+        return getReflected().getVisibility();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isFinal() {
+        return getReflected().isFinal();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isOpen() {
+        return getReflected().isOpen();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isAbstract() {
+        return getReflected().isAbstract();
+    }
+
+    @Override // kotlin.reflect.KCallable
+    public boolean isSuspend() {
+        return getReflected().isSuspend();
+    }
+}