Java Code Examples for java.lang.reflect.WildcardType#getUpperBounds()

/**
 * Returns a type that is functionally equal but not necessarily equal according to {@link
 * Object#equals(Object) Object.equals()}.
 */
public static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

  } else if (type instanceof ParameterizedType) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    if (type instanceof GenericArrayTypeImpl) return type;
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    if (type instanceof WildcardTypeImpl) return type;
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    return type; // This type is unsupported!
  }
}
 

/**
 * Get a {@link WildcardBounds} instance for the specified type, returning
 * {@code null} if the specified type cannot be resolved to a {@link WildcardType}.
 * @param type the source type
 * @return a {@link WildcardBounds} instance or {@code null}
 */
public static WildcardBounds get(ResolvableType type) {
	ResolvableType resolveToWildcard = type;
	while (!(resolveToWildcard.getType() instanceof WildcardType)) {
		if (resolveToWildcard == NONE) {
			return null;
		}
		resolveToWildcard = resolveToWildcard.resolveType();
	}
	WildcardType wildcardType = (WildcardType) resolveToWildcard.type;
	Kind boundsType = (wildcardType.getLowerBounds().length > 0 ? Kind.LOWER : Kind.UPPER);
	Type[] bounds = (boundsType == Kind.UPPER ? wildcardType.getUpperBounds() : wildcardType.getLowerBounds());
	ResolvableType[] resolvableBounds = new ResolvableType[bounds.length];
	for (int i = 0; i < bounds.length; i++) {
		resolvableBounds[i] = ResolvableType.forType(bounds[i], type.variableResolver);
	}
	return new WildcardBounds(boundsType, resolvableBounds);
}
 

public static Class<?> getCollectionItemClass(Type fieldType){
    if(fieldType instanceof ParameterizedType){
        Class<?> itemClass;
        Type actualTypeArgument = ((ParameterizedType) fieldType).getActualTypeArguments()[0];
        if(actualTypeArgument instanceof WildcardType){
            WildcardType wildcardType = (WildcardType) actualTypeArgument;
            Type[] upperBounds = wildcardType.getUpperBounds();
            if(upperBounds.length == 1){
                actualTypeArgument = upperBounds[0];
            }
        }
        if(actualTypeArgument instanceof Class){
            itemClass = (Class<?>) actualTypeArgument;
            if(!Modifier.isPublic(itemClass.getModifiers())){
                throw new JSONException("can not create ASMParser");
            }
        } else{
            throw new JSONException("can not create ASMParser");
        }
        return itemClass;
    }
    return Object.class;
}
 

private static JavaType constructWildCardType(WildcardType type) {
    // For our simplified type system we can safely replace upper bounds
    // When registering a transformer to type ? extends SomeType the
    // transformer is guaranteed to produce an object that is an instance of
    // SomeType.
    // When transforming a data table to ? extends SomeType a transformer
    // that produces SomeType is sufficient.
    // This will result in ambiguity between a transformers for SomeType
    // and transformers for ? extends SomeType but that seems reasonable and
    // might be resolved by using a more specific producer.
    Type[] upperBounds = type.getUpperBounds();
    if (upperBounds.length > 0) {
        // Not possible in Java. Scala?
        if (upperBounds.length > 1) {
            throw new IllegalArgumentException("Type contained more then upper lower bound " + type + ". Types may only have a single upper bound.");
        }
        return constructType(upperBounds[0]);
    }

    // We'll treat lower bounds as is.
    return new OtherType(type);
}
 

@Override
Class<?> toRawType(Type type, Class<?> implClass) {
    WildcardType wType = (WildcardType) type;

    Type[] lowerTypes = wType.getLowerBounds();
    if (lowerTypes.length > 0) {
        return getRawType(lowerTypes[0], implClass);
    }

    Type[] upperTypes = wType.getUpperBounds();
    if (upperTypes.length != 0) {
        return getRawType(upperTypes[0], implClass);
    }

    return Object.class;
}
 

private static Class<?> getGenericClass(ParameterizedType parameterizedType, int i) {
    Type genericClass = null;
    try {
        genericClass = parameterizedType.getActualTypeArguments()[i];
    } catch (Exception e) {
        return null;
    }

    if (genericClass instanceof ParameterizedType) {
        return (Class) ((ParameterizedType) genericClass).getRawType();
    } else if (genericClass instanceof GenericArrayType) {
        return (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType();
    } else if (genericClass instanceof TypeVariable) {
        return getClass(((TypeVariable) genericClass).getBounds()[0], 0);
    } else if (genericClass instanceof WildcardType) {
        WildcardType wuleType = (WildcardType) genericClass;
        if (null != wuleType.getUpperBounds()[0]) {
            return getClass(wuleType.getUpperBounds()[0], 0);
        } else {
            return getClass(wuleType.getLowerBounds()[0], 0);
        }

    } else {
        return (Class<?>) genericClass;
    }
}
 

private void checkLowerBoundedParameter(Method method) {
    Type genericParameterType = method.getGenericParameterTypes()[0];
    assertInstanceOf(ParameterizedType.class, genericParameterType);

    ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;

    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    assertLenghtOne(actualTypeArguments);
    assertInstanceOf(WildcardType.class, actualTypeArguments[0]);

    WildcardType wildcardType = (WildcardType) actualTypeArguments[0];
    assertEquals("? super T", wildcardType.toString());
    assertEquals("? super T", wildcardType.getTypeName());

    Type[] lowerBounds = wildcardType.getLowerBounds();
    assertLenghtOne(lowerBounds);
    Type lowerBound = lowerBounds[0];
    assertEquals(getTypeParameter(method), lowerBound);

    Type[] upperBounds = wildcardType.getUpperBounds();
    assertEquals(Object.class, upperBounds[0]);
}
 

/**
 * Returns a type that is functionally equal but not necessarily equal according to {@link
 * Object#equals(Object) Object.equals()}.
 */
static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(c.getComponentType()) : c;

  } else if (type instanceof ParameterizedType) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(
        p.getOwnerType(), p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    if (type instanceof GenericArrayTypeImpl) return type;
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    if (type instanceof WildcardTypeImpl) return type;
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    return type; // This type is unsupported!
  }
}
 

/**
 * Determine whether the underlying type represents a wildcard
 * without specific bounds (i.e., equal to {@code ? extends Object}).
 */
private boolean isWildcardWithoutBounds() {
	if (this.type instanceof WildcardType) {
		WildcardType wt = (WildcardType) this.type;
		if (wt.getLowerBounds().length == 0) {
			Type[] upperBounds = wt.getUpperBounds();
			if (upperBounds.length == 0 || (upperBounds.length == 1 && Object.class == upperBounds[0])) {
				return true;
			}
		}
	}
	return false;
}
 

@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
  // TODO check if GSON does caching of the created TypeAdapter for the given type

  // extra caching could be added in this layer if there is only one polymorphic type
  // adapter for the whole hierarchy

  // https://google.github.io/gson/apidocs/com/google/gson/TypeAdapterFactory.html
  // If a factory cannot support a given type, it must return null when that type is passed to create(com.google.gson.Gson, com.google.gson.reflect.TypeToken<T>)

  if (type.getType() instanceof WildcardType) {
    WildcardType wildcardType = (WildcardType) type.getType();
    Type[] upperBounds = wildcardType.getUpperBounds();
    if (upperBounds!=null && upperBounds.length==1) {
      type = (TypeToken<T>) TypeToken.get(upperBounds[0]);
    } else {
      throw new RuntimeException("Unsupported wildcard type: "+type);
    }
  }
  if (matchingTypes.contains(type)) {
    if (typeAdapter==null) {
      typeAdapter = new PolymorphicTypeAdapter<T>(type, this, gson);
    }
    return (TypeAdapter<T>) this.typeAdapter;
  }

  return null;
}
 

/**
 * Returns a type that is functionally equal but not necessarily equal
 * according to {@link Object#equals(Object) Object.equals()}.
 */
public static Type canonicalize(Type type) {
    if (type instanceof ParameterizedTypeImpl
            || type instanceof GenericArrayTypeImpl
            || type instanceof WildcardTypeImpl) {
        return type;

    } else if (type instanceof ParameterizedType) {
        ParameterizedType p = (ParameterizedType) type;
        return new ParameterizedTypeImpl(p.getOwnerType(),
                p.getRawType(), p.getActualTypeArguments());

    } else if (type instanceof GenericArrayType) {
        GenericArrayType g = (GenericArrayType) type;
        return new GenericArrayTypeImpl(g.getGenericComponentType());

    } else if (type instanceof Class && ((Class<?>) type).isArray()) {
        Class<?> c = (Class<?>) type;
        return new GenericArrayTypeImpl(c.getComponentType());

    } else if (type instanceof WildcardType) {
        WildcardType w = (WildcardType) type;
        return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

    } else {
        // type is either serializable as-is or unsupported
        return type;
    }
}
 

@Override
public Type[] getActualTypeArguments() {
    final Type[] resolvedTypes = new Type[this.m_pType.getActualTypeArguments().length];
    for (int i = 0; i < this.m_pType.getActualTypeArguments().length; i++) {
        final Type actualType = this.m_pType.getActualTypeArguments()[i];
        if (actualType instanceof WildcardType) {
            final WildcardType actualWildcardType = (WildcardType) actualType;
            final Type resolvedType = new WildcardType() {
                @Override
                public Type[] getUpperBounds() {
                    final Type[] resolvedUpperBounds = new Type[actualWildcardType.getUpperBounds().length];
                    for (int j = 0; j < actualWildcardType.getUpperBounds().length; j++) {
                        resolvedUpperBounds[j] = m_typeVariables.get(((TypeVariable<?>) actualWildcardType.getUpperBounds()[j]).getName());
                    }
                    return resolvedUpperBounds;
                }

                @Override
                public Type[] getLowerBounds() {
                    final Type[] resolvedLowerBounds = new Type[actualWildcardType.getLowerBounds().length];
                    for (int j = 0; j < actualWildcardType.getLowerBounds().length; j++) {
                        resolvedLowerBounds[j] = m_typeVariables.get(((TypeVariable<?>) actualWildcardType.getLowerBounds()[j]).getName());
                    }
                    return resolvedLowerBounds;
                }
            };
            resolvedTypes[i] = resolvedType;
        } else {
            throw new UnsupportedOperationException("Currently only WildcardType is supported");
        }
    }
    return resolvedTypes;
}
 

/**
 * Finds the Type value of the given wildcard type, using recursiveBounds to
 * limit the recursion.
 *
 * @param var
 * @param recursiveBounds
 *
 * @return the resolved Type instance
 */
public static <T> Type<T> limitedValueOf(final WildcardType var,
                                         final Set<java.lang.reflect.Type> recursiveBounds) {
    Set<Type<?>> bounds = new HashSet<Type<?>>(var.getUpperBounds().length + var.getLowerBounds().length);
    for (int i = 0, len = var.getUpperBounds().length; i < len; ++i) {
        bounds.add(limitedValueOf(var.getUpperBounds()[i], recursiveBounds));
    }
    for (int i = 0, len = var.getLowerBounds().length; i < len; ++i) {
        bounds.add(limitedValueOf(var.getLowerBounds()[i], recursiveBounds));
    }
    return (Type<T>) refineBounds(bounds);
}
 

Type capture(Type type) {
  checkNotNull(type);
  if (type instanceof Class) {
    return type;
  }
  if (type instanceof TypeVariable) {
    return type;
  }
  if (type instanceof GenericArrayType) {
    GenericArrayType arrayType = (GenericArrayType) type;
    return Types.newArrayType(capture(arrayType.getGenericComponentType()));
  }
  if (type instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) type;
    return Types.newParameterizedTypeWithOwner(captureNullable(parameterizedType.getOwnerType()), (Class<?>) parameterizedType.getRawType(), capture(parameterizedType.getActualTypeArguments()));
  }
  if (type instanceof WildcardType) {
    WildcardType wildcardType = (WildcardType) type;
    Type[] lowerBounds = wildcardType.getLowerBounds();
    if (lowerBounds.length == 0) { // ? extends something changes to capture-of
      Type[] upperBounds = wildcardType.getUpperBounds();
      String name =
        "capture#" + id.incrementAndGet() + "-of ? extends "
          + Joiner.on('&').join(upperBounds);
      return Types.newArtificialTypeVariable(WildcardCapturer.class, name, wildcardType.getUpperBounds());
    } else {
      // TODO(benyu): handle ? super T somehow.
      return type;
    }
  }
  throw new AssertionError("must have been one of the known types");
}
 

public static Type canonicalize(Type type)
{
    if (type instanceof Class)
    {
        type = (Class)type;
        if (type.isArray())
        {
            type = new a(canonicalize(((Type) (type.getComponentType()))));
        }
    } else
    {
        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)
        {
            WildcardType wildcardtype = (WildcardType)type;
            return new c(wildcardtype.getUpperBounds(), wildcardtype.getLowerBounds());
        }
    }
    return type;
}
 

public static ArrayList<Type> extracQualifiedGenTypes(ParameterizedType asParType,  Map<String, GenericType> nameToGenericMap, boolean dontSetupInterfaceGenerics){
	java.lang.reflect.Type[] parTypes =  asParType.getActualTypeArguments();
	ArrayList<Type> QualifiedgenTypes = new ArrayList<Type>(parTypes.length);
	
	for( java.lang.reflect.Type partype : parTypes ){
		//TODO: cater for all of these: GenericArrayType
		//so these todo: GenericArrayType, ParameterizedType
		//System.err.println("gens: " + partype);
		if(partype instanceof TypeVariable){//generic
			//String genParName = (((TypeVariable<?>)partype).getName());
			//QualifiedgenTypes.add(nameToGenericMap.get(genParName));
			
			QualifiedgenTypes.add(convertGenType(partype, nameToGenericMap, dontSetupInterfaceGenerics));
			
		}
		else if (partype instanceof WildcardType){
			WildcardType wc = (WildcardType)partype;
			java.lang.reflect.Type[] bound = wc.getLowerBounds();
			boolean hasLower = bound != null && bound.length!=0;
			if(!hasLower){
				bound = wc.getUpperBounds(); 
			}
			
			Type tt = convertGenType(bound[0], nameToGenericMap, dontSetupInterfaceGenerics);
			tt = tt==null?null:(Type)tt.copy();//why would tt be null?
			
			if(!hasLower && tt.equals(ScopeAndTypeChecker.const_object)){
				if(tt instanceof NamedType){
					((NamedType)tt).isWildCardAny = true;
				}
				if(tt instanceof GenericType){
					((GenericType)tt).isWildcard=true;
				}
			}else{
				if(null == wc.getUpperBounds() && null == wc.getLowerBounds()){//ArrayList<?>
					if(tt instanceof NamedType){
						((NamedType)tt).isWildCardAny = true;
					}
					if(tt instanceof GenericType){
						((GenericType)tt).isWildcard=true;
					}
				}
				else if(tt != null){//ArrayList<? extends Number>
					tt.setInOutGenModifier(hasLower?InoutGenericModifier.IN:InoutGenericModifier.OUT);
					
					/*if(tt instanceof NamedType){
						((NamedType)tt).isWildCardAny = true;
					}
					if(tt instanceof GenericType){
						((GenericType)tt).isWildcard=true;
					}*/
					
				}
			}
			
			
			
			QualifiedgenTypes.add(tt);
		}
		else if(partype instanceof Class<?>){
			QualifiedgenTypes.add(convertGenType(partype, nameToGenericMap, dontSetupInterfaceGenerics));
			//dontSetupInterfaceGenerics - prevents infinite loop with Int -> Comparable<Int> which gets expanded forever
		}
		else if(partype instanceof ParameterizedType){
			QualifiedgenTypes.add(convertGenType(partype, nameToGenericMap, dontSetupInterfaceGenerics));
		}
		else if(partype instanceof GenericArrayType) {
			GenericArrayType gat = (GenericArrayType)partype;
			
			QualifiedgenTypes.add(convertGenType(gat.getGenericComponentType(), nameToGenericMap, dontSetupInterfaceGenerics));
		}else{
			throw new RuntimeException("Unexpected Parameterized type in convertGenType: " + partype);
		}
	}
	return QualifiedgenTypes;
}
 

/**
 * Tests if a generic type (may be <?>, <? extends {required}> 
 * or <? super {required}>) is compatible with the required one.
 * TODO: Should be moved to an utility class
 * @param required the required class the generic type MUST BE compatible with
 * @param genericType the required class
 * @return if the generic type is compatible with the required class
 */
public static boolean testType(Class<?> required, Type type) {
    //for the examples let assume that a Set is the raw type and the
    //requested generic type is a Representation with the following class
    //hierarchy:
    // Object
    //     -> Representation
    //         -> RdfRepresentation
    //         -> InMemoryRepresentation
    //     -> InputStream
    //     -> Collection<T>
    boolean typeOK = false;
    if(type instanceof Class<?>){
        typeOK = required.isAssignableFrom((Class<?>) type);
        type = ((Class<?>)type).getGenericSuperclass();
    } else if(type instanceof WildcardType){
        //In cases <? super {class}>, <? extends {class}, <?>
        WildcardType wildcardSetType = (WildcardType) type;
        if(wildcardSetType.getLowerBounds().length > 0){
            Type lowerBound = wildcardSetType.getLowerBounds()[0];
            //OK
            //  Set<? super RdfRepresentation>
            //  Set<? super Representation>
            //NOT OK
            //  Set<? super InputStream>
            //  Set<? super Collection<Representation>>
            typeOK = lowerBound instanceof Class<?> &&
                required.isAssignableFrom((Class<?>)lowerBound);
        } else if (wildcardSetType.getUpperBounds().length > 0){
            Type upperBound = wildcardSetType.getUpperBounds()[0];
            //OK
            //  Set<? extends Representation>
            //  Set<? extends Object>
            //NOT OK
            //  Set<? extends RdfRepresentation>
            //  Set<? extends InputStream>
            //  Set<? extends Collection<Representation>
            typeOK = upperBound instanceof Class<?> &&
                ((Class<?>)upperBound).isAssignableFrom(required); 
        } else { //no upper nor lower bound
            // Set<?>
            typeOK = true;
        }
    } else if(required.isArray() && type instanceof GenericArrayType){
        //In case the required type is an array we need also to support 
        //possible generic Array specifications
        GenericArrayType arrayType = (GenericArrayType)type;
        typeOK = testType(required.getComponentType(), arrayType.getGenericComponentType());
    } else if(type instanceof ParameterizedType){
        ParameterizedType pType = ((ParameterizedType)type);
        typeOK = pType.getRawType() instanceof Class<?> && 
                required.isAssignableFrom((Class<?>)pType.getRawType());
        type = null;
    } else {
        typeOK = false;
    }
    return typeOK;
}
 

private WildcardType resolveWildcardType(WildcardType type) {
  Type[] lowerBounds = type.getLowerBounds();
  Type[] upperBounds = type.getUpperBounds();
  return new Types.WildcardTypeImpl(resolveTypes(lowerBounds), resolveTypes(upperBounds));
}
 

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;
        }
    }
}
 

/**
 * <p> Returns an array containing the sole value of {@link Object} if
 * {@link WildcardType#getUpperBounds()} returns an empty array. Otherwise,
 * it returns the result of <code>WildcardType.getUpperBounds()</code>
 * passed into {@link #normalizeUpperBounds}. </p>
 *
 * @param wildcardType the subject wildcard type
 * @return a non-empty array containing the upper bounds of the wildcard
 * type.
 */
public static Type[] getImplicitUpperBounds(final WildcardType wildcardType) {
    final Type[] bounds = wildcardType.getUpperBounds();

    return bounds.length == 0 ? new Type[] { Object.class } : normalizeUpperBounds(bounds);
}