Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/k1/C0416a.java

@@ -0,0 +1,56 @@
+package k1;
+
+import com.adif.elcanomovil.domain.entities.utils.AsyncResult;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* renamed from: k1.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0416a extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7017a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7018b;
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.Continuation, kotlin.coroutines.jvm.internal.SuspendLambda, k1.a] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ?? suspendLambda = new SuspendLambda(2, continuation);
+        suspendLambda.f7018b = obj;
+        return suspendLambda;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0416a) create((FlowCollector) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7017a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            FlowCollector flowCollector = (FlowCollector) this.f7018b;
+            AsyncResult success = AsyncResult.INSTANCE.success(CollectionsKt.emptyList());
+            this.f7017a = 1;
+            if (flowCollector.emit(success, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/k1/b.java

@@ -0,0 +1,85 @@
+package k1;
+
+import com.adif.elcanomovil.domain.repositories.compositions.CompositionsRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetCompositionsUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+/* loaded from: classes.dex */
+public final class b extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7019a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ boolean f7020b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetCompositionsUseCase f7021c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7022d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7023e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ long f7024f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ String f7025g;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(boolean z3, GetCompositionsUseCase getCompositionsUseCase, String str, String str2, long j4, String str3, Continuation continuation) {
+        super(2, continuation);
+        this.f7020b = z3;
+        this.f7021c = getCompositionsUseCase;
+        this.f7022d = str;
+        this.f7023e = str2;
+        this.f7024f = j4;
+        this.f7025g = str3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new b(this.f7020b, this.f7021c, this.f7022d, this.f7023e, this.f7024f, this.f7025g, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((b) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r10v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        CompositionsRepository compositionsRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7019a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            if (!this.f7020b) {
+                return FlowKt.flow(new SuspendLambda(2, null));
+            }
+            compositionsRepository = this.f7021c.compositionsRepository;
+            this.f7019a = 1;
+            obj = compositionsRepository.compositions(this.f7022d, this.f7023e, this.f7024f, this.f7025g, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return (Flow) obj;
+    }
+}

apk_decompiled/sources/k1/c.java

@@ -0,0 +1,60 @@
+package k1;
+
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import java.util.Collection;
+import java.util.List;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* loaded from: classes.dex */
+public final class c extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public GetDepartureCirculationsUseCase f7026a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object f7027b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Object f7028c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public Object f7029d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Object f7030e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public Collection f7031f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public List f7032g;
+    public int h;
+    public int i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public boolean f7033j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public /* synthetic */ Object f7034k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7035l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public int f7036m;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public c(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, Continuation continuation) {
+        super(continuation);
+        this.f7035l = getDepartureCirculationsUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.f7034k = obj;
+        this.f7036m |= IntCompanionObject.MIN_VALUE;
+        return this.f7035l.invoke(null, null, null, null, 0, false, false, this);
+    }
+}

apk_decompiled/sources/k1/d.java

@@ -0,0 +1,71 @@
+package k1;
+
+import com.adif.elcanomovil.domain.entities.CirculationType;
+import com.adif.elcanomovil.domain.entities.TrainType;
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import java.util.List;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes.dex */
+public final class d extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7037a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7038b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7039c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ CirculationType f7040d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ TrainType f7041e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public d(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, CirculationType circulationType, TrainType trainType, Continuation continuation) {
+        super(2, continuation);
+        this.f7039c = getDepartureCirculationsUseCase;
+        this.f7040d = circulationType;
+        this.f7041e = trainType;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        d dVar = new d(this.f7039c, this.f7040d, this.f7041e, continuation);
+        dVar.f7038b = obj;
+        return dVar;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((d) create((List) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object mapToCirculation;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7037a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        List list = (List) this.f7038b;
+        boolean z3 = this.f7040d == CirculationType.DEPARTURE;
+        this.f7037a = 1;
+        mapToCirculation = this.f7039c.mapToCirculation(list, z3, this.f7041e, this);
+        return mapToCirculation == coroutine_suspended ? coroutine_suspended : mapToCirculation;
+    }
+}

apk_decompiled/sources/k1/e.java

@@ -0,0 +1,37 @@
+package k1;
+
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* loaded from: classes.dex */
+public final class e extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public GetDepartureCirculationsUseCase f7042a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7043b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7044c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f7045d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public e(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, Continuation continuation) {
+        super(continuation);
+        this.f7044c = getDepartureCirculationsUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object mapToCirculation;
+        this.f7043b = obj;
+        this.f7045d |= IntCompanionObject.MIN_VALUE;
+        mapToCirculation = this.f7044c.mapToCirculation(null, false, null, this);
+        return mapToCirculation;
+    }
+}

apk_decompiled/sources/k1/f.java

@@ -0,0 +1,64 @@
+package k1;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetSeveralPathsUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class f extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7046a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetSeveralPathsUseCase f7047b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7048c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ boolean f7049d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public f(GetSeveralPathsUseCase getSeveralPathsUseCase, String str, boolean z3, Continuation continuation) {
+        super(2, continuation);
+        this.f7047b = getSeveralPathsUseCase;
+        this.f7048c = str;
+        this.f7049d = z3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new f(this.f7047b, this.f7048c, this.f7049d, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((f) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        CirculationRepository circulationRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7046a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        circulationRepository = this.f7047b.circulationRepository;
+        this.f7046a = 1;
+        Object severalPaths = circulationRepository.severalPaths(this.f7048c, this.f7049d, this);
+        return severalPaths == coroutine_suspended ? coroutine_suspended : severalPaths;
+    }
+}