468 lines
18 KiB
Java
468 lines
18 KiB
Java
package retrofit2;
|
|
|
|
import C.w;
|
|
import e3.T;
|
|
import java.io.IOException;
|
|
import java.lang.annotation.Annotation;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.GenericArrayType;
|
|
import java.lang.reflect.Method;
|
|
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.NoSuchElementException;
|
|
import java.util.Objects;
|
|
import r3.InterfaceC0578j;
|
|
|
|
/* loaded from: classes3.dex */
|
|
final class Utils {
|
|
static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
|
|
|
|
/* loaded from: classes3.dex */
|
|
public static final class GenericArrayTypeImpl implements GenericArrayType {
|
|
private final Type componentType;
|
|
|
|
public GenericArrayTypeImpl(Type type) {
|
|
this.componentType = type;
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
return (obj instanceof GenericArrayType) && Utils.equals(this, (GenericArrayType) obj);
|
|
}
|
|
|
|
@Override // java.lang.reflect.GenericArrayType
|
|
public Type getGenericComponentType() {
|
|
return this.componentType;
|
|
}
|
|
|
|
public int hashCode() {
|
|
return this.componentType.hashCode();
|
|
}
|
|
|
|
public String toString() {
|
|
return w.r(new StringBuilder(), Utils.typeToString(this.componentType), "[]");
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
public static final class ParameterizedTypeImpl implements ParameterizedType {
|
|
private final Type ownerType;
|
|
private final Type rawType;
|
|
private final Type[] typeArguments;
|
|
|
|
public ParameterizedTypeImpl(Type type, Type type2, Type... typeArr) {
|
|
if (type2 instanceof Class) {
|
|
if ((type == null) != (((Class) type2).getEnclosingClass() == null)) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
for (Type type3 : typeArr) {
|
|
Objects.requireNonNull(type3, "typeArgument == null");
|
|
Utils.checkNotPrimitive(type3);
|
|
}
|
|
this.ownerType = type;
|
|
this.rawType = type2;
|
|
this.typeArguments = (Type[]) typeArr.clone();
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
return (obj instanceof ParameterizedType) && Utils.equals(this, (ParameterizedType) obj);
|
|
}
|
|
|
|
@Override // java.lang.reflect.ParameterizedType
|
|
public Type[] getActualTypeArguments() {
|
|
return (Type[]) this.typeArguments.clone();
|
|
}
|
|
|
|
@Override // java.lang.reflect.ParameterizedType
|
|
public Type getOwnerType() {
|
|
return this.ownerType;
|
|
}
|
|
|
|
@Override // java.lang.reflect.ParameterizedType
|
|
public Type getRawType() {
|
|
return this.rawType;
|
|
}
|
|
|
|
public int hashCode() {
|
|
int hashCode = Arrays.hashCode(this.typeArguments) ^ this.rawType.hashCode();
|
|
Type type = this.ownerType;
|
|
return (type != null ? type.hashCode() : 0) ^ hashCode;
|
|
}
|
|
|
|
public String toString() {
|
|
Type[] typeArr = this.typeArguments;
|
|
if (typeArr.length == 0) {
|
|
return Utils.typeToString(this.rawType);
|
|
}
|
|
StringBuilder sb = new StringBuilder((typeArr.length + 1) * 30);
|
|
sb.append(Utils.typeToString(this.rawType));
|
|
sb.append("<");
|
|
sb.append(Utils.typeToString(this.typeArguments[0]));
|
|
for (int i = 1; i < this.typeArguments.length; i++) {
|
|
sb.append(", ");
|
|
sb.append(Utils.typeToString(this.typeArguments[i]));
|
|
}
|
|
sb.append(">");
|
|
return sb.toString();
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
public static final class WildcardTypeImpl implements WildcardType {
|
|
private final Type lowerBound;
|
|
private final Type upperBound;
|
|
|
|
public WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
|
|
if (typeArr2.length > 1) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (typeArr.length != 1) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (typeArr2.length != 1) {
|
|
typeArr[0].getClass();
|
|
Utils.checkNotPrimitive(typeArr[0]);
|
|
this.lowerBound = null;
|
|
this.upperBound = typeArr[0];
|
|
return;
|
|
}
|
|
typeArr2[0].getClass();
|
|
Utils.checkNotPrimitive(typeArr2[0]);
|
|
if (typeArr[0] != Object.class) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
this.lowerBound = typeArr2[0];
|
|
this.upperBound = Object.class;
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
return (obj instanceof WildcardType) && Utils.equals(this, (WildcardType) obj);
|
|
}
|
|
|
|
@Override // java.lang.reflect.WildcardType
|
|
public Type[] getLowerBounds() {
|
|
Type type = this.lowerBound;
|
|
return type != null ? new Type[]{type} : Utils.EMPTY_TYPE_ARRAY;
|
|
}
|
|
|
|
@Override // java.lang.reflect.WildcardType
|
|
public Type[] getUpperBounds() {
|
|
return new Type[]{this.upperBound};
|
|
}
|
|
|
|
public int hashCode() {
|
|
Type type = this.lowerBound;
|
|
return (this.upperBound.hashCode() + 31) ^ (type != null ? type.hashCode() + 31 : 1);
|
|
}
|
|
|
|
public String toString() {
|
|
if (this.lowerBound != null) {
|
|
return "? super " + Utils.typeToString(this.lowerBound);
|
|
}
|
|
if (this.upperBound == Object.class) {
|
|
return "?";
|
|
}
|
|
return "? extends " + Utils.typeToString(this.upperBound);
|
|
}
|
|
}
|
|
|
|
private Utils() {
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Type inference failed for: r0v0, types: [r3.i, r3.j, java.lang.Object] */
|
|
public static T buffer(T t2) throws IOException {
|
|
?? obj = new Object();
|
|
t2.source().U(obj);
|
|
return T.create(t2.contentType(), t2.contentLength(), (InterfaceC0578j) obj);
|
|
}
|
|
|
|
public static void checkNotPrimitive(Type type) {
|
|
if ((type instanceof Class) && ((Class) type).isPrimitive()) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) {
|
|
Object genericDeclaration = typeVariable.getGenericDeclaration();
|
|
if (genericDeclaration instanceof Class) {
|
|
return (Class) genericDeclaration;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static boolean equals(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;
|
|
Type ownerType = parameterizedType.getOwnerType();
|
|
Type ownerType2 = parameterizedType2.getOwnerType();
|
|
return (ownerType == ownerType2 || (ownerType != null && ownerType.equals(ownerType2))) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
if (type2 instanceof GenericArrayType) {
|
|
return equals(((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 Type getGenericSupertype(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 getGenericSupertype(cls.getGenericInterfaces()[i], interfaces[i], cls2);
|
|
}
|
|
}
|
|
}
|
|
if (!cls.isInterface()) {
|
|
while (cls != Object.class) {
|
|
Class<? super Object> superclass = cls.getSuperclass();
|
|
if (superclass == cls2) {
|
|
return cls.getGenericSuperclass();
|
|
}
|
|
if (cls2.isAssignableFrom(superclass)) {
|
|
return getGenericSupertype(cls.getGenericSuperclass(), superclass, cls2);
|
|
}
|
|
cls = superclass;
|
|
}
|
|
}
|
|
return cls2;
|
|
}
|
|
|
|
public static Type getParameterLowerBound(int i, ParameterizedType parameterizedType) {
|
|
Type type = parameterizedType.getActualTypeArguments()[i];
|
|
return type instanceof WildcardType ? ((WildcardType) type).getLowerBounds()[0] : type;
|
|
}
|
|
|
|
public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
|
|
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
|
if (i >= 0 && i < actualTypeArguments.length) {
|
|
Type type = actualTypeArguments[i];
|
|
return type instanceof WildcardType ? ((WildcardType) type).getUpperBounds()[0] : type;
|
|
}
|
|
StringBuilder t2 = w.t(i, "Index ", " not in range [0,");
|
|
t2.append(actualTypeArguments.length);
|
|
t2.append(") for ");
|
|
t2.append(parameterizedType);
|
|
throw new IllegalArgumentException(t2.toString());
|
|
}
|
|
|
|
public static Class<?> getRawType(Type type) {
|
|
Objects.requireNonNull(type, "type == null");
|
|
if (type instanceof Class) {
|
|
return (Class) type;
|
|
}
|
|
if (type instanceof ParameterizedType) {
|
|
Type rawType = ((ParameterizedType) type).getRawType();
|
|
if (rawType instanceof Class) {
|
|
return (Class) rawType;
|
|
}
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
return Array.newInstance(getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
|
|
}
|
|
if (type instanceof TypeVariable) {
|
|
return Object.class;
|
|
}
|
|
if (type instanceof WildcardType) {
|
|
return getRawType(((WildcardType) type).getUpperBounds()[0]);
|
|
}
|
|
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
|
|
}
|
|
|
|
public static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
|
|
if (cls2.isAssignableFrom(cls)) {
|
|
return resolve(type, cls, getGenericSupertype(type, cls, cls2));
|
|
}
|
|
throw new IllegalArgumentException();
|
|
}
|
|
|
|
public static boolean hasUnresolvableType(Type type) {
|
|
if (type instanceof Class) {
|
|
return false;
|
|
}
|
|
if (type instanceof ParameterizedType) {
|
|
for (Type type2 : ((ParameterizedType) type).getActualTypeArguments()) {
|
|
if (hasUnresolvableType(type2)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
if (type instanceof GenericArrayType) {
|
|
return hasUnresolvableType(((GenericArrayType) type).getGenericComponentType());
|
|
}
|
|
if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
|
|
return true;
|
|
}
|
|
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
|
|
}
|
|
|
|
private static int indexOf(Object[] objArr, Object obj) {
|
|
for (int i = 0; i < objArr.length; i++) {
|
|
if (obj.equals(objArr[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
public static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
|
|
for (Annotation annotation : annotationArr) {
|
|
if (cls.isInstance(annotation)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static RuntimeException methodError(Method method, String str, Object... objArr) {
|
|
return methodError(method, null, str, objArr);
|
|
}
|
|
|
|
public static RuntimeException parameterError(Method method, Throwable th, int i, String str, Object... objArr) {
|
|
return methodError(method, th, str + " (parameter #" + (i + 1) + ")", objArr);
|
|
}
|
|
|
|
public static Type resolve(Type type, Class<?> cls, Type type2) {
|
|
Type type3 = type2;
|
|
while (type3 instanceof TypeVariable) {
|
|
TypeVariable typeVariable = (TypeVariable) type3;
|
|
Type resolveTypeVariable = resolveTypeVariable(type, cls, typeVariable);
|
|
if (resolveTypeVariable == typeVariable) {
|
|
return resolveTypeVariable;
|
|
}
|
|
type3 = resolveTypeVariable;
|
|
}
|
|
if (type3 instanceof Class) {
|
|
Class cls2 = (Class) type3;
|
|
if (cls2.isArray()) {
|
|
Class<?> componentType = cls2.getComponentType();
|
|
Type resolve = resolve(type, cls, componentType);
|
|
return componentType == resolve ? cls2 : new GenericArrayTypeImpl(resolve);
|
|
}
|
|
}
|
|
if (type3 instanceof GenericArrayType) {
|
|
GenericArrayType genericArrayType = (GenericArrayType) type3;
|
|
Type genericComponentType = genericArrayType.getGenericComponentType();
|
|
Type resolve2 = resolve(type, cls, genericComponentType);
|
|
return genericComponentType == resolve2 ? genericArrayType : new GenericArrayTypeImpl(resolve2);
|
|
}
|
|
if (type3 instanceof ParameterizedType) {
|
|
ParameterizedType parameterizedType = (ParameterizedType) type3;
|
|
Type ownerType = parameterizedType.getOwnerType();
|
|
Type resolve3 = resolve(type, cls, ownerType);
|
|
boolean z3 = resolve3 != ownerType;
|
|
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
|
int length = actualTypeArguments.length;
|
|
for (int i = 0; i < length; i++) {
|
|
Type resolve4 = resolve(type, cls, actualTypeArguments[i]);
|
|
if (resolve4 != actualTypeArguments[i]) {
|
|
if (!z3) {
|
|
actualTypeArguments = (Type[]) actualTypeArguments.clone();
|
|
z3 = true;
|
|
}
|
|
actualTypeArguments[i] = resolve4;
|
|
}
|
|
}
|
|
return z3 ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
|
|
}
|
|
boolean z4 = type3 instanceof WildcardType;
|
|
Type type4 = type3;
|
|
if (z4) {
|
|
WildcardType wildcardType = (WildcardType) type3;
|
|
Type[] lowerBounds = wildcardType.getLowerBounds();
|
|
Type[] upperBounds = wildcardType.getUpperBounds();
|
|
if (lowerBounds.length == 1) {
|
|
Type resolve5 = resolve(type, cls, lowerBounds[0]);
|
|
type4 = wildcardType;
|
|
if (resolve5 != lowerBounds[0]) {
|
|
return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{resolve5});
|
|
}
|
|
} else {
|
|
type4 = wildcardType;
|
|
if (upperBounds.length == 1) {
|
|
Type resolve6 = resolve(type, cls, upperBounds[0]);
|
|
type4 = wildcardType;
|
|
if (resolve6 != upperBounds[0]) {
|
|
return new WildcardTypeImpl(new Type[]{resolve6}, EMPTY_TYPE_ARRAY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return type4;
|
|
}
|
|
|
|
private static Type resolveTypeVariable(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
|
|
Class<?> declaringClassOf = declaringClassOf(typeVariable);
|
|
if (declaringClassOf != null) {
|
|
Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
|
|
if (genericSupertype instanceof ParameterizedType) {
|
|
return ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
|
|
}
|
|
}
|
|
return typeVariable;
|
|
}
|
|
|
|
public static void throwIfFatal(Throwable th) {
|
|
if (th instanceof VirtualMachineError) {
|
|
throw ((VirtualMachineError) th);
|
|
}
|
|
if (th instanceof ThreadDeath) {
|
|
throw ((ThreadDeath) th);
|
|
}
|
|
if (th instanceof LinkageError) {
|
|
throw ((LinkageError) th);
|
|
}
|
|
}
|
|
|
|
public static String typeToString(Type type) {
|
|
return type instanceof Class ? ((Class) type).getName() : type.toString();
|
|
}
|
|
|
|
public static RuntimeException methodError(Method method, Throwable th, String str, Object... objArr) {
|
|
return new IllegalArgumentException(String.format(str, objArr) + "\n for method " + method.getDeclaringClass().getSimpleName() + "." + method.getName(), th);
|
|
}
|
|
|
|
public static RuntimeException parameterError(Method method, int i, String str, Object... objArr) {
|
|
return methodError(method, str + " (parameter #" + (i + 1) + ")", objArr);
|
|
}
|
|
}
|