package com.google.gson.internal; import java.io.Serializable; import java.lang.reflect.Array; import java.lang.reflect.GenericArrayType; import java.lang.reflect.GenericDeclaration; 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.Collection; import java.util.Map; import java.util.NoSuchElementException; import java.util.Properties; import org.cybergarage.upnp.std.av.server.object.SearchCriteria; public final class C$Gson$Types { static final Type[] EMPTY_TYPE_ARRAY = new Type[0]; /* compiled from: $Gson$Types */ private static final class GenericArrayTypeImpl implements GenericArrayType, Serializable { private static final long serialVersionUID = 0; private final Type componentType; public GenericArrayTypeImpl(Type componentType) { this.componentType = C$Gson$Types.canonicalize(componentType); } public Type getGenericComponentType() { return this.componentType; } public boolean equals(Object o) { return (o instanceof GenericArrayType) && C$Gson$Types.equals(this, (GenericArrayType) o); } public int hashCode() { return this.componentType.hashCode(); } public String toString() { return C$Gson$Types.typeToString(this.componentType) + "[]"; } } /* compiled from: $Gson$Types */ private static final class ParameterizedTypeImpl implements ParameterizedType, Serializable { private static final long serialVersionUID = 0; private final Type ownerType; private final Type rawType; private final Type[] typeArguments; public ParameterizedTypeImpl(Type ownerType, Type rawType, Type... typeArguments) { boolean z = false; if (rawType instanceof Class) { boolean z2; Class<?> rawTypeAsClass = (Class) rawType; if (ownerType != null || rawTypeAsClass.getEnclosingClass() == null) { z2 = true; } else { z2 = false; } C$Gson$Preconditions.checkArgument(z2); if (ownerType == null || rawTypeAsClass.getEnclosingClass() != null) { z = true; } C$Gson$Preconditions.checkArgument(z); } this.ownerType = ownerType == null ? null : C$Gson$Types.canonicalize(ownerType); this.rawType = C$Gson$Types.canonicalize(rawType); this.typeArguments = (Type[]) typeArguments.clone(); for (int t = 0; t < this.typeArguments.length; t++) { C$Gson$Preconditions.checkNotNull(this.typeArguments[t]); C$Gson$Types.checkNotPrimitive(this.typeArguments[t]); this.typeArguments[t] = C$Gson$Types.canonicalize(this.typeArguments[t]); } } public Type[] getActualTypeArguments() { return (Type[]) this.typeArguments.clone(); } public Type getRawType() { return this.rawType; } public Type getOwnerType() { return this.ownerType; } public boolean equals(Object other) { return (other instanceof ParameterizedType) && C$Gson$Types.equals(this, (ParameterizedType) other); } public int hashCode() { return (Arrays.hashCode(this.typeArguments) ^ this.rawType.hashCode()) ^ C$Gson$Types.hashCodeOrZero(this.ownerType); } public String toString() { StringBuilder stringBuilder = new StringBuilder((this.typeArguments.length + 1) * 30); stringBuilder.append(C$Gson$Types.typeToString(this.rawType)); if (this.typeArguments.length == 0) { return stringBuilder.toString(); } stringBuilder.append(SearchCriteria.LT).append(C$Gson$Types.typeToString(this.typeArguments[0])); for (int i = 1; i < this.typeArguments.length; i++) { stringBuilder.append(", ").append(C$Gson$Types.typeToString(this.typeArguments[i])); } return stringBuilder.append(SearchCriteria.GT).toString(); } } /* compiled from: $Gson$Types */ private static final class WildcardTypeImpl implements WildcardType, Serializable { private static final long serialVersionUID = 0; private final Type lowerBound; private final Type upperBound; public WildcardTypeImpl(Type[] upperBounds, Type[] lowerBounds) { boolean z; boolean z2 = true; C$Gson$Preconditions.checkArgument(lowerBounds.length <= 1); if (upperBounds.length == 1) { z = true; } else { z = false; } C$Gson$Preconditions.checkArgument(z); if (lowerBounds.length == 1) { C$Gson$Preconditions.checkNotNull(lowerBounds[0]); C$Gson$Types.checkNotPrimitive(lowerBounds[0]); if (upperBounds[0] != Object.class) { z2 = false; } C$Gson$Preconditions.checkArgument(z2); this.lowerBound = C$Gson$Types.canonicalize(lowerBounds[0]); this.upperBound = Object.class; return; } C$Gson$Preconditions.checkNotNull(upperBounds[0]); C$Gson$Types.checkNotPrimitive(upperBounds[0]); this.lowerBound = null; this.upperBound = C$Gson$Types.canonicalize(upperBounds[0]); } public Type[] getUpperBounds() { return new Type[]{this.upperBound}; } public Type[] getLowerBounds() { if (this.lowerBound == null) { return C$Gson$Types.EMPTY_TYPE_ARRAY; } return new Type[]{this.lowerBound}; } public boolean equals(Object other) { return (other instanceof WildcardType) && C$Gson$Types.equals(this, (WildcardType) other); } public int hashCode() { return (this.lowerBound != null ? this.lowerBound.hashCode() + 31 : 1) ^ (this.upperBound.hashCode() + 31); } public String toString() { if (this.lowerBound != null) { return "? super " + C$Gson$Types.typeToString(this.lowerBound); } if (this.upperBound == Object.class) { return "?"; } return "? extends " + C$Gson$Types.typeToString(this.upperBound); } } private C$Gson$Types() { } public static ParameterizedType newParameterizedTypeWithOwner(Type ownerType, Type rawType, Type... typeArguments) { return new ParameterizedTypeImpl(ownerType, rawType, typeArguments); } public static GenericArrayType arrayOf(Type componentType) { return new GenericArrayTypeImpl(componentType); } public static WildcardType subtypeOf(Type bound) { return new WildcardTypeImpl(new Type[]{bound}, EMPTY_TYPE_ARRAY); } public static WildcardType supertypeOf(Type bound) { return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{bound}); } public static Type canonicalize(Type type) { if (type instanceof Class) { Class<?> c = (Class) type; return c.isArray() ? new GenericArrayTypeImpl(C$Gson$Types.canonicalize(c.getComponentType())) : c; } else if (type instanceof ParameterizedType) { ParameterizedType p = (ParameterizedType) type; return new ParameterizedTypeImpl(p.getOwnerType(), p.getRawType(), p.getActualTypeArguments()); } else if (type instanceof GenericArrayType) { return new GenericArrayTypeImpl(((GenericArrayType) type).getGenericComponentType()); } else { if (!(type instanceof WildcardType)) { return type; } WildcardType w = (WildcardType) type; return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds()); } } public static Class<?> getRawType(Type type) { if (type instanceof Class) { return (Class) type; } if (type instanceof ParameterizedType) { Type rawType = ((ParameterizedType) type).getRawType(); C$Gson$Preconditions.checkArgument(rawType instanceof Class); return (Class) rawType; } else if (type instanceof GenericArrayType) { return Array.newInstance(C$Gson$Types.getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass(); } else { if (type instanceof TypeVariable) { return Object.class; } if (type instanceof WildcardType) { return C$Gson$Types.getRawType(((WildcardType) type).getUpperBounds()[0]); } throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName())); } } static boolean equal(Object a, Object b) { return a == b || (a != null && a.equals(b)); } public static boolean equals(Type a, Type b) { boolean z = true; if (a == b) { return true; } if (a instanceof Class) { return a.equals(b); } if (a instanceof ParameterizedType) { if (!(b instanceof ParameterizedType)) { return false; } ParameterizedType pa = (ParameterizedType) a; ParameterizedType pb = (ParameterizedType) b; if (!(C$Gson$Types.equal(pa.getOwnerType(), pb.getOwnerType()) && pa.getRawType().equals(pb.getRawType()) && Arrays.equals(pa.getActualTypeArguments(), pb.getActualTypeArguments()))) { z = false; } return z; } else if (a instanceof GenericArrayType) { if (!(b instanceof GenericArrayType)) { return false; } return C$Gson$Types.equals(((GenericArrayType) a).getGenericComponentType(), ((GenericArrayType) b).getGenericComponentType()); } else if (a instanceof WildcardType) { if (!(b instanceof WildcardType)) { return false; } WildcardType wa = (WildcardType) a; WildcardType wb = (WildcardType) b; if (!(Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds()) && Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds()))) { z = false; } return z; } else if (!(a instanceof TypeVariable) || !(b instanceof TypeVariable)) { return false; } else { TypeVariable<?> va = (TypeVariable) a; TypeVariable<?> vb = (TypeVariable) b; if (!(va.getGenericDeclaration() == vb.getGenericDeclaration() && va.getName().equals(vb.getName()))) { z = false; } return z; } } private static int hashCodeOrZero(Object o) { return o != null ? o.hashCode() : 0; } public static String typeToString(Type type) { return type instanceof Class ? ((Class) type).getName() : type.toString(); } static Type getGenericSupertype(Type context, Class<?> rawType, Class<?> toResolve) { if (toResolve == rawType) { return context; } if (toResolve.isInterface()) { Class<?>[] interfaces = rawType.getInterfaces(); int length = interfaces.length; for (int i = 0; i < length; i++) { if (interfaces[i] == toResolve) { return rawType.getGenericInterfaces()[i]; } if (toResolve.isAssignableFrom(interfaces[i])) { return C$Gson$Types.getGenericSupertype(rawType.getGenericInterfaces()[i], interfaces[i], toResolve); } } } if (!rawType.isInterface()) { while (rawType != Object.class) { Class<?> rawSupertype = rawType.getSuperclass(); if (rawSupertype == toResolve) { return rawType.getGenericSuperclass(); } if (toResolve.isAssignableFrom(rawSupertype)) { return C$Gson$Types.getGenericSupertype(rawType.getGenericSuperclass(), rawSupertype, toResolve); } rawType = rawSupertype; } } return toResolve; } static Type getSupertype(Type context, Class<?> contextRawType, Class<?> supertype) { C$Gson$Preconditions.checkArgument(supertype.isAssignableFrom(contextRawType)); return C$Gson$Types.resolve(context, contextRawType, C$Gson$Types.getGenericSupertype(context, contextRawType, supertype)); } public static Type getArrayComponentType(Type array) { return array instanceof GenericArrayType ? ((GenericArrayType) array).getGenericComponentType() : ((Class) array).getComponentType(); } public static Type getCollectionElementType(Type context, Class<?> contextRawType) { Type collectionType = C$Gson$Types.getSupertype(context, contextRawType, Collection.class); if (collectionType instanceof WildcardType) { collectionType = ((WildcardType) collectionType).getUpperBounds()[0]; } if (collectionType instanceof ParameterizedType) { return ((ParameterizedType) collectionType).getActualTypeArguments()[0]; } return Object.class; } public static Type[] getMapKeyAndValueTypes(Type context, Class<?> contextRawType) { if (context == Properties.class) { return new Type[]{String.class, String.class}; } Type mapType = C$Gson$Types.getSupertype(context, contextRawType, Map.class); if (mapType instanceof ParameterizedType) { return ((ParameterizedType) mapType).getActualTypeArguments(); } return new Type[]{Object.class, Object.class}; } public static Type resolve(Type context, Class<?> contextRawType, Type toResolve) { while (toResolve instanceof TypeVariable) { TypeVariable<?> typeVariable = (TypeVariable) toResolve; toResolve = C$Gson$Types.resolveTypeVariable(context, contextRawType, typeVariable); if (toResolve == typeVariable) { return toResolve; } } Type componentType; Type newComponentType; if ((toResolve instanceof Class) && ((Class) toResolve).isArray()) { Class<?> original = (Class) toResolve; componentType = original.getComponentType(); newComponentType = C$Gson$Types.resolve(context, contextRawType, componentType); if (componentType != newComponentType) { original = C$Gson$Types.arrayOf(newComponentType); } return original; } else if (toResolve instanceof GenericArrayType) { GenericArrayType original2 = (GenericArrayType) toResolve; componentType = original2.getGenericComponentType(); newComponentType = C$Gson$Types.resolve(context, contextRawType, componentType); if (componentType != newComponentType) { return C$Gson$Types.arrayOf(newComponentType); } return original2; } else if (toResolve instanceof ParameterizedType) { ParameterizedType original3 = (ParameterizedType) toResolve; Type ownerType = original3.getOwnerType(); Type newOwnerType = C$Gson$Types.resolve(context, contextRawType, ownerType); boolean changed = newOwnerType != ownerType; Type[] args = original3.getActualTypeArguments(); int length = args.length; for (int t = 0; t < length; t++) { Type resolvedTypeArgument = C$Gson$Types.resolve(context, contextRawType, args[t]); if (resolvedTypeArgument != args[t]) { if (!changed) { args = (Type[]) args.clone(); changed = true; } args[t] = resolvedTypeArgument; } } if (changed) { return C$Gson$Types.newParameterizedTypeWithOwner(newOwnerType, original3.getRawType(), args); } return original3; } else if (!(toResolve instanceof WildcardType)) { return toResolve; } else { WildcardType original4 = (WildcardType) toResolve; Type[] originalLowerBound = original4.getLowerBounds(); Type[] originalUpperBound = original4.getUpperBounds(); if (originalLowerBound.length == 1) { Type lowerBound = C$Gson$Types.resolve(context, contextRawType, originalLowerBound[0]); if (lowerBound != originalLowerBound[0]) { return C$Gson$Types.supertypeOf(lowerBound); } return original4; } else if (originalUpperBound.length != 1) { return original4; } else { Type upperBound = C$Gson$Types.resolve(context, contextRawType, originalUpperBound[0]); if (upperBound != originalUpperBound[0]) { return C$Gson$Types.subtypeOf(upperBound); } return original4; } } } static Type resolveTypeVariable(Type context, Class<?> contextRawType, TypeVariable<?> unknown) { Class<?> declaredByRaw = C$Gson$Types.declaringClassOf(unknown); if (declaredByRaw == null) { return unknown; } Type declaredBy = C$Gson$Types.getGenericSupertype(context, contextRawType, declaredByRaw); if (!(declaredBy instanceof ParameterizedType)) { return unknown; } return ((ParameterizedType) declaredBy).getActualTypeArguments()[C$Gson$Types.indexOf(declaredByRaw.getTypeParameters(), unknown)]; } private static int indexOf(Object[] array, Object toFind) { for (int i = 0; i < array.length; i++) { if (toFind.equals(array[i])) { return i; } } throw new NoSuchElementException(); } private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) { GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration(); return genericDeclaration instanceof Class ? (Class) genericDeclaration : null; } private static void checkNotPrimitive(Type type) { boolean z = ((type instanceof Class) && ((Class) type).isPrimitive()) ? false : true; C$Gson$Preconditions.checkArgument(z); } }