193 lines
8.2 KiB
Java
193 lines
8.2 KiB
Java
package S2;
|
|
|
|
import C.w;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.GenericArrayType;
|
|
import java.lang.reflect.ParameterizedType;
|
|
import java.lang.reflect.Type;
|
|
import java.lang.reflect.TypeVariable;
|
|
import java.lang.reflect.WildcardType;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
|
|
/* loaded from: classes3.dex */
|
|
public abstract class d {
|
|
|
|
/* renamed from: a, reason: collision with root package name */
|
|
public static final Type[] f1586a = new Type[0];
|
|
|
|
public static Type a(Type type) {
|
|
if (type instanceof Class) {
|
|
Class cls = (Class) type;
|
|
return cls.isArray() ? new a(a(cls.getComponentType())) : cls;
|
|
}
|
|
if (type instanceof ParameterizedType) {
|
|
ParameterizedType parameterizedType = (ParameterizedType) type;
|
|
return new b(parameterizedType.getOwnerType(), parameterizedType.getRawType(), parameterizedType.getActualTypeArguments());
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
return new a(((GenericArrayType) type).getGenericComponentType());
|
|
}
|
|
if (!(type instanceof WildcardType)) {
|
|
return type;
|
|
}
|
|
WildcardType wildcardType = (WildcardType) type;
|
|
return new c(wildcardType.getUpperBounds(), wildcardType.getLowerBounds());
|
|
}
|
|
|
|
public static void b(boolean z3) {
|
|
if (!z3) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
public static void c(Type type) {
|
|
b(((type instanceof Class) && ((Class) type).isPrimitive()) ? false : true);
|
|
}
|
|
|
|
public static boolean d(Type type, Type type2) {
|
|
if (type == type2) {
|
|
return true;
|
|
}
|
|
if (type instanceof Class) {
|
|
return type.equals(type2);
|
|
}
|
|
if (type instanceof ParameterizedType) {
|
|
if (!(type2 instanceof ParameterizedType)) {
|
|
return false;
|
|
}
|
|
ParameterizedType parameterizedType = (ParameterizedType) type;
|
|
ParameterizedType parameterizedType2 = (ParameterizedType) type2;
|
|
return Objects.equals(parameterizedType.getOwnerType(), parameterizedType2.getOwnerType()) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
if (type2 instanceof GenericArrayType) {
|
|
return d(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
|
|
}
|
|
return false;
|
|
}
|
|
if (type instanceof WildcardType) {
|
|
if (!(type2 instanceof WildcardType)) {
|
|
return false;
|
|
}
|
|
WildcardType wildcardType = (WildcardType) type;
|
|
WildcardType wildcardType2 = (WildcardType) type2;
|
|
return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
|
|
}
|
|
if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
|
|
return false;
|
|
}
|
|
TypeVariable typeVariable = (TypeVariable) type;
|
|
TypeVariable typeVariable2 = (TypeVariable) type2;
|
|
return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
|
|
}
|
|
|
|
public static void e(List list) {
|
|
Iterator it = list.iterator();
|
|
if (it.hasNext()) {
|
|
throw w.g(it);
|
|
}
|
|
}
|
|
|
|
public static Type f(Type type, Class cls, Class cls2) {
|
|
if (cls2 == cls) {
|
|
return type;
|
|
}
|
|
if (cls2.isInterface()) {
|
|
Class<?>[] interfaces = cls.getInterfaces();
|
|
int length = interfaces.length;
|
|
for (int i = 0; i < length; i++) {
|
|
Class<?> cls3 = interfaces[i];
|
|
if (cls3 == cls2) {
|
|
return cls.getGenericInterfaces()[i];
|
|
}
|
|
if (cls2.isAssignableFrom(cls3)) {
|
|
return f(cls.getGenericInterfaces()[i], interfaces[i], cls2);
|
|
}
|
|
}
|
|
}
|
|
if (!cls.isInterface()) {
|
|
while (cls != Object.class) {
|
|
Class<?> superclass = cls.getSuperclass();
|
|
if (superclass == cls2) {
|
|
return cls.getGenericSuperclass();
|
|
}
|
|
if (cls2.isAssignableFrom(superclass)) {
|
|
return f(cls.getGenericSuperclass(), superclass, cls2);
|
|
}
|
|
cls = superclass;
|
|
}
|
|
}
|
|
return cls2;
|
|
}
|
|
|
|
public static Class g(Type type) {
|
|
if (type instanceof Class) {
|
|
return (Class) type;
|
|
}
|
|
if (type instanceof ParameterizedType) {
|
|
Type rawType = ((ParameterizedType) type).getRawType();
|
|
b(rawType instanceof Class);
|
|
return (Class) rawType;
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
return Array.newInstance((Class<?>) g(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
|
|
}
|
|
if (type instanceof TypeVariable) {
|
|
return Object.class;
|
|
}
|
|
if (type instanceof WildcardType) {
|
|
return g(((WildcardType) type).getUpperBounds()[0]);
|
|
}
|
|
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:25:0x013b, code lost:
|
|
|
|
if (r3 == null) goto L81;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:26:0x013d, code lost:
|
|
|
|
r12.put(r3, r11);
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:27:0x0140, code lost:
|
|
|
|
return r11;
|
|
*/
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Removed duplicated region for block: B:24:0x013b A[EDGE_INSN: B:24:0x013b->B:25:0x013b BREAK A[LOOP:0: B:2:0x0004->B:29:?], SYNTHETIC] */
|
|
/* JADX WARN: Removed duplicated region for block: B:29:? A[LOOP:0: B:2:0x0004->B:29:?, LOOP_END, SYNTHETIC] */
|
|
/* JADX WARN: Type inference failed for: r11v0, types: [java.lang.reflect.Type] */
|
|
/* JADX WARN: Type inference failed for: r11v1, types: [java.lang.reflect.Type] */
|
|
/* JADX WARN: Type inference failed for: r11v10, types: [java.lang.reflect.Type, java.lang.Object] */
|
|
/* JADX WARN: Type inference failed for: r11v14 */
|
|
/* JADX WARN: Type inference failed for: r11v15 */
|
|
/* JADX WARN: Type inference failed for: r11v17, types: [java.lang.reflect.Type[]] */
|
|
/* JADX WARN: Type inference failed for: r11v18 */
|
|
/* JADX WARN: Type inference failed for: r11v2, types: [java.lang.reflect.WildcardType] */
|
|
/* JADX WARN: Type inference failed for: r11v3, types: [S2.c] */
|
|
/* JADX WARN: Type inference failed for: r11v4, types: [S2.c] */
|
|
/* JADX WARN: Type inference failed for: r11v5, types: [java.lang.reflect.ParameterizedType] */
|
|
/* JADX WARN: Type inference failed for: r11v6, types: [java.lang.reflect.GenericArrayType] */
|
|
/* JADX WARN: Type inference failed for: r11v7 */
|
|
/* JADX WARN: Type inference failed for: r11v9 */
|
|
/* JADX WARN: Type inference failed for: r12v0, types: [java.util.HashMap] */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public static java.lang.reflect.Type h(java.lang.reflect.Type r9, java.lang.Class r10, java.lang.reflect.Type r11, java.util.HashMap r12) {
|
|
/*
|
|
Method dump skipped, instructions count: 321
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: S2.d.h(java.lang.reflect.Type, java.lang.Class, java.lang.reflect.Type, java.util.HashMap):java.lang.reflect.Type");
|
|
}
|
|
|
|
public static String i(Type type) {
|
|
return type instanceof Class ? ((Class) type).getName() : type.toString();
|
|
}
|
|
}
|