/** * Determines the key type for a Map. * * @param type The parametrized type. * @param path The path to the type, used in exception message. * @return The key type. */ public static Type[] mapTypes(Type type, String path) { if (type instanceof Class) { Class c = (Class) type; type = c.getGenericSuperclass(); if (!(isGenericMap(type))) { Type[] types = c.getGenericInterfaces(); if (types != null && types.length > 0) { for (Type t : types) { if (isGenericMap(t)) { type = t; break; } } } } } if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; Class<?> rawType = (Class<?>) parameterizedType.getRawType(); if (Map.class.isAssignableFrom(rawType)) { return parameterizedType.getActualTypeArguments(); } } throw new CollectionExpressionException( "The method or member [" + path + "] returns a simple Map. Unable to determine the " + "types of the Map. Please make this method or member generic so that the correct type can be determined."); }
@Override public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) { Type type = extractionContext.getType().getType(); if (!(type instanceof Class)) { return; } Class<?> contractType = (Class<?>) type; if (!contractType.isInterface()) { return; } if (contractType.getGenericInterfaces().length != 1) { return; } Type superType = contractType.getGenericInterfaces()[0]; if (!(superType instanceof ParameterizedType)) { return; } ParameterizedType parameterizedSuperType = (ParameterizedType) superType; if (!parameterizedSuperType.getRawType().equals(ModelMap.class)) { return; } ModelType<?> elementType = ModelType.of(parameterizedSuperType.getActualTypeArguments()[0]); Class<?> proxyImpl = generator.generate(ModelMapGroovyDecorator.Managed.class, contractType); extractionContext.found( new SpecializedMapSchema<T>(extractionContext.getType(), elementType, proxyImpl)); }
public static boolean isAssignableFrom( Class<?> rawType1, Type[] actualTypeArguments1, Type type2) { if (type2 instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type2; if (parameterizedType.getRawType() instanceof Class<?>) { if (isAssignableFrom( rawType1, actualTypeArguments1, (Class<?>) parameterizedType.getRawType(), parameterizedType.getActualTypeArguments())) { return true; } } } else if (type2 instanceof Class<?>) { Class<?> clazz = (Class<?>) type2; if (isAssignableFrom(rawType1, actualTypeArguments1, clazz, EMPTY_TYPES)) { return true; } } else if (type2 instanceof TypeVariable<?>) { TypeVariable<?> typeVariable = (TypeVariable<?>) type2; if (isTypeBounded(rawType1, actualTypeArguments1, typeVariable.getBounds())) { return true; } } return false; }
private Object convert( Type targetType, Object sourceObject, Action<? super SourceObjectMapping> mapping) { if (targetType instanceof ParameterizedType) { ParameterizedType parameterizedTargetType = (ParameterizedType) targetType; if (parameterizedTargetType.getRawType() instanceof Class) { Class<?> rawClass = (Class<?>) parameterizedTargetType.getRawType(); if (Iterable.class.isAssignableFrom(rawClass)) { Type targetElementType = getElementType(parameterizedTargetType, 0); return convertCollectionInternal( rawClass, targetElementType, (Iterable<?>) sourceObject, mapping); } if (Map.class.isAssignableFrom(rawClass)) { Type targetKeyType = getElementType(parameterizedTargetType, 0); Type targetValueType = getElementType(parameterizedTargetType, 1); return convertMap( rawClass, targetKeyType, targetValueType, (Map<?, ?>) sourceObject, mapping); } } } if (targetType instanceof Class) { if (((Class) targetType).isPrimitive()) { return sourceObject; } return adapt((Class) targetType, sourceObject, mapping); } throw new UnsupportedOperationException( String.format("Cannot convert object of %s to %s.", sourceObject.getClass(), targetType)); }
private static boolean isCollection(Type type) { if (type instanceof ParameterizedType) { ParameterizedType ptype = (ParameterizedType) type; return Collection.class.isAssignableFrom((Class<?>) ptype.getRawType()) || Map.class.isAssignableFrom((Class<?>) ptype.getRawType()); } return Collection.class.isAssignableFrom((Class<?>) type); }
private static ClassTypePair resolveTypeVariable( ParameterizedType pt, Class c, Class dc, TypeVariable tv, Map<TypeVariable, Type> map) { Type[] typeArguments = pt.getActualTypeArguments(); TypeVariable[] typeParameters = c.getTypeParameters(); Map<TypeVariable, Type> submap = new HashMap<TypeVariable, Type>(); for (int i = 0; i < typeArguments.length; i++) { // Substitute a type variable with the Java class if (typeArguments[i] instanceof TypeVariable) { Type t = map.get(typeArguments[i]); submap.put(typeParameters[i], t); } else { submap.put(typeParameters[i], typeArguments[i]); } } if (c == dc) { Type t = submap.get(tv); if (t instanceof Class) { return new ClassTypePair((Class) t); } else if (t instanceof GenericArrayType) { t = ((GenericArrayType) t).getGenericComponentType(); if (t instanceof Class) { c = (Class) t; try { return new ClassTypePair(getArrayClass(c)); } catch (Exception e) { } return null; } else if (t instanceof ParameterizedType) { Type rt = ((ParameterizedType) t).getRawType(); if (rt instanceof Class) { c = (Class) rt; } else { return null; } try { return new ClassTypePair(getArrayClass(c), t); } catch (Exception e) { return null; } } else { return null; } } else if (t instanceof ParameterizedType) { pt = (ParameterizedType) t; if (pt.getRawType() instanceof Class) { return new ClassTypePair((Class) pt.getRawType(), pt); } else return null; } else { return null; } } else { return resolveTypeVariable(c, dc, tv, submap); } }
private void addType(Type cls, boolean allowArray) { if (cls instanceof Class) { if (globalAdapters.contains(cls)) { return; } if (((Class<?>) cls).isArray() && !allowArray) { addClass(((Class<?>) cls).getComponentType()); } else { addClass((Class<?>) cls); } } else if (cls instanceof ParameterizedType) { final ParameterizedType parameterizedType = (ParameterizedType) cls; addType(parameterizedType.getRawType()); if (!parameterizedType.getRawType().equals(Enum.class)) { for (Type t2 : parameterizedType.getActualTypeArguments()) { if (shouldTypeBeAdded(t2, parameterizedType)) { addType(t2); } } } } else if (cls instanceof GenericArrayType) { Class<?> ct; GenericArrayType gt = (GenericArrayType) cls; Type componentType = gt.getGenericComponentType(); if (componentType instanceof Class) { ct = (Class<?>) componentType; } else { TypeVariable<?> tv = (TypeVariable<?>) componentType; Type[] bounds = tv.getBounds(); if (bounds != null && bounds.length == 1) { if (bounds[0] instanceof Class) { ct = (Class<?>) bounds[0]; } else { throw new IllegalArgumentException("Unable to determine type for: " + tv); } } else { throw new IllegalArgumentException("Unable to determine type for: " + tv); } } ct = Array.newInstance(ct, 0).getClass(); addClass(ct); } else if (cls instanceof WildcardType) { for (Type t : ((WildcardType) cls).getUpperBounds()) { addType(t); } for (Type t : ((WildcardType) cls).getLowerBounds()) { addType(t); } } else if (cls instanceof TypeVariable) { for (Type t : ((TypeVariable<?>) cls).getBounds()) { addType(t); } } }
/** Returns true if {@code a} and {@code b} are equal. */ public static boolean equals(Type a, Type b) { if (a == b) { // also handles (a == null && b == null) return true; } else if (a instanceof Class) { // Class already specifies equals(). return a.equals(b); } else if (a instanceof ParameterizedType) { if (!(b instanceof ParameterizedType)) { return false; } // TODO: save a .clone() call ParameterizedType pa = (ParameterizedType) a; ParameterizedType pb = (ParameterizedType) b; return equal(pa.getOwnerType(), pb.getOwnerType()) && pa.getRawType().equals(pb.getRawType()) && Arrays.equals(pa.getActualTypeArguments(), pb.getActualTypeArguments()); } else if (a instanceof GenericArrayType) { if (!(b instanceof GenericArrayType)) { return false; } GenericArrayType ga = (GenericArrayType) a; GenericArrayType gb = (GenericArrayType) b; return equals(ga.getGenericComponentType(), gb.getGenericComponentType()); } else if (a instanceof WildcardType) { if (!(b instanceof WildcardType)) { return false; } WildcardType wa = (WildcardType) a; WildcardType wb = (WildcardType) b; return Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds()) && Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds()); } else if (a instanceof TypeVariable) { if (!(b instanceof TypeVariable)) { return false; } TypeVariable<?> va = (TypeVariable<?>) a; TypeVariable<?> vb = (TypeVariable<?>) b; return va.getGenericDeclaration() == vb.getGenericDeclaration() && va.getName().equals(vb.getName()); } else { // This isn't a type we support. Could be a generic array type, // wildcard type, etc. return false; } }
private static Type getDefaultType( Type type, Map<TypeVariable<?>, Type> handledArguments, TypeVariable<?> currentArgument) { if (type instanceof Class) { return type; } else if (type instanceof TypeVariable<?>) { Type handledArgument = handledArguments.get(type); if (handledArgument != null) { return handledArgument; } if (type == currentArgument) { // class Enum<E extends Enum<? extends E>> and class Enum<E extends Enum<E>> return currentArgument; } return null; } else if (type instanceof GenericArrayType) { Type componentType = ((GenericArrayType) type).getGenericComponentType(); Type defaultComponentType = getDefaultType(componentType, handledArguments, currentArgument); if (defaultComponentType != null) { return new GenericArrayTypeImpl(defaultComponentType); } return null; } else if (type instanceof WildcardType) { Type[] varBounds = ((WildcardType) type).getUpperBounds(); Type varType = getDefaultType(varBounds, handledArguments, currentArgument); if (varType != null) { return varType; } return null; } else { ParameterizedType parameterizedType = (ParameterizedType) type; Type[] vars = parameterizedType .getActualTypeArguments(); // F<T extends Serializable & List<? extends X>, X, Y // extends T> -->> ? extends X Type[] tranedArguments = new Type[vars.length]; for (int i = 0; i < vars.length; i++) { Type var = vars[i]; Type defaultVar = getDefaultType(var, handledArguments, currentArgument); if (defaultVar == null) { return null; } else if (defaultVar == currentArgument) { // class Enum<E extends Enum<? extends E>> vs class Enum<E extends Enum<E>> // 出现递归,则忽略所有参数? N extends Map<N, Object> ==>> Map // TODO N extends Map<N, Object> ==>> Map<Map<Map<...>>, Object> return parameterizedType.getRawType(); } else { tranedArguments[i] = defaultVar; } } return new ParameterizedTypeImpl(parameterizedType.getRawType(), tranedArguments); } }
/* * Enabled force condition propagation * Lifted jumps to return sites */ private static boolean typeEquals(ParameterizedType arrtype, ParameterizedType arrtype2, Map<String, Type> map) { if (!arrtype.getRawType().equals(arrtype2.getRawType())) return false; arrtype = arrtype.getActualTypeArguments(); arrtype2 = arrtype2.getActualTypeArguments(); int n2 = 0; while (n2 < arrtype.length) { if (!TypeToken.matches(arrtype[n2], arrtype2[n2], map)) { return false; } ++n2; } return true; }
/** * Checks if two parameterized types are exactly equal, under the variable replacement described * in the typeVarMap. */ private static boolean typeEquals( ParameterizedType from, ParameterizedType to, Map<String, Type> typeVarMap) { if (from.getRawType().equals(to.getRawType())) { Type[] fromArgs = from.getActualTypeArguments(); Type[] toArgs = to.getActualTypeArguments(); for (int i = 0; i < fromArgs.length; i++) { if (!matches(fromArgs[i], toArgs[i], typeVarMap)) { return false; } } return true; } return false; }
private static Class getClass(Type type) { if (type instanceof Class) { return (Class) type; } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; if (parameterizedType.getRawType() instanceof Class) { return (Class) parameterizedType.getRawType(); } } throw new IllegalArgumentException( "Type parameter [" + type.toString() + "] not a class or " + "parameterized type whose raw type is a class"); }
public void testResolveToGenericArrayType() { GenericArrayType arrayType = (GenericArrayType) new Holder<List<int[][]>[]>() {}.getContentType(); ParameterizedType listType = (ParameterizedType) arrayType.getGenericComponentType(); assertEquals(List.class, listType.getRawType()); assertEquals(Types.newArrayType(int[].class), listType.getActualTypeArguments()[0]); }
@Nullable private static TypeWrapper wrap(Type type) { if (type == null) { return null; } else if (type instanceof Class) { return new ClassTypeWrapper((Class<?>) type); } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; return new ParameterizedTypeWrapper( toWrappers(parameterizedType.getActualTypeArguments()), (ClassTypeWrapper) wrap(parameterizedType.getRawType()), wrap(parameterizedType.getOwnerType())); } else if (type instanceof WildcardType) { WildcardType wildcardType = (WildcardType) type; return new WildcardTypeWrapper( toWrappers(wildcardType.getUpperBounds()), toWrappers(wildcardType.getLowerBounds()), type.hashCode()); } else if (type instanceof TypeVariable) { TypeVariable<?> typeVariable = (TypeVariable<?>) type; return new TypeVariableTypeWrapper( typeVariable.getName(), toWrappers(typeVariable.getBounds()), type.hashCode()); } else if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type; return new GenericArrayTypeWrapper( wrap(genericArrayType.getGenericComponentType()), type.hashCode()); } else { throw new IllegalArgumentException("cannot wrap type of type " + type.getClass()); } }
public static Class<?> getRawType(Type type) { if (type instanceof Class<?>) { // type is a normal class. return (Class<?>) type; } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; // I'm not exactly sure why getRawType() returns Type instead of Class. // Neal isn't either but suspects some pathological case related // to nested classes exists. Type rawType = parameterizedType.getRawType(); // checkArgument(rawType instanceof Class, // "Expected a Class, but <%s> is of type %s", type, type.getClass().getName()); return (Class<?>) rawType; } else if (type instanceof GenericArrayType) { // TODO: Is this sufficient? return Object[].class; } else if (type instanceof TypeVariable) { // we could use the variable's bounds, but that'll won't work if there are multiple. // having a raw type that's more general than necessary is okay return Object.class; } else { throw new IllegalArgumentException( "Expected a Class, ParameterizedType, or " + "GenericArrayType, but <" + type + "> is of type " + type.getClass().getName()); } }
private static GenericType getFieldType( VariableMapping currentMapping, Class<?> startClass, String fieldname) { Type type = null; Field field = null; // e.g. BClass<String, Integer> bObject; { Class<?> ownerClass = startClass; findfield: while (true) { Field[] fields = ownerClass.getDeclaredFields(); for (Field f : fields) { if (f.getName().equals(fieldname)) { field = f; break findfield; } } // field not found so far // -> search superclass Type superType = ownerClass.getGenericSuperclass(); if (superType instanceof ParameterizedType) { ParameterizedType parameterizedSuperType = (ParameterizedType) superType; currentMapping = new VariableMapping(currentMapping, parameterizedSuperType); ownerClass = (Class<?>) parameterizedSuperType.getRawType(); } else if (superType instanceof Class<?>) { ownerClass = (Class<?>) superType; } else { throw new IllegalStateException(); } } } type = field.getGenericType(); // e.g. BClass<String, Integer> return getGenericType(currentMapping, type); }
private static VariableMapping resolveTypeVariableInParameterizedType( TypeVariable<?> var, ParameterizedType inParameterizedType, VariableMapping currentMapping) { assertThatTypeVariableDoesParameterizeAClass(var); currentMapping = new VariableMapping(currentMapping, inParameterizedType); Class<?> inClass = (Class<?>) inParameterizedType.getRawType(); return resolveTypeVariableInClass(var, inClass, currentMapping); }
/** * Returns the value of the given {@link TypeVariable} as a {@link GenericType}. * * @param variable must parameterize this type or one of it's super types * @return the actual value of the given {@link TypeVariable} as a {@link GenericType} * @throws IllegalArgumentException if the variable does not parameterize this type * @throws UnsupportedOperationException if the type parameter resolution is not supported for * this type */ public GenericType getTypeParameter(TypeVariable<? extends Class<?>> variable) throws IllegalArgumentException, IllegalStateException { assertThatTypeVariableDoesParameterizeAClass(variable); GenericType result = null; if (type instanceof Class<?>) { Class<?> cls = (Class<?>) type; // Class<?> parameterizedClass = (Class<?>) // variable.getGenericDeclaration(); // // Break-Condition // if (parameterizedClass.equals(cls)) { // GenericType result = new GenericType(mapping, variable); // return result; // } VariableMapping aMapping = resolveTypeVariableInClass(variable, cls, mapping); if (aMapping != null) { result = getGenericType(aMapping, variable); } } else if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; Class<?> rawType = (Class<?>) pType.getRawType(); VariableMapping aMapping = resolveTypeVariableInClass(variable, rawType, mapping); if (aMapping != null) { result = getGenericType(aMapping, variable); } } else { throw new UnsupportedOperationException( String.format("Type parameter resolution not supported for %s", type)); } if (result == null) { throw new IllegalArgumentException( String.format("%s does not parameterize this type %s!", variable, type)); } else { return result; } }
public static Set<Class<?>> getReferencedClasses( Set<Type> referencedTypes, TypescriptServiceGeneratorConfiguration settings) { Set<Class<?>> ret = Sets.newHashSet(); for (Type t : referencedTypes) { if (settings.ignoredClasses().contains(t)) { continue; } if (t instanceof Class && ((Class<?>) t).isEnum()) { ret.add((Class<?>) t); continue; } // dummy context used for below check Context nullContext = new Context(new SymbolTable(settings.getSettings()), settings.customTypeProcessor()); // Don't add any classes that the user has made an exception for if (settings.customTypeProcessor().processType(t, nullContext) == null) { if (t instanceof Class) { ret.add((Class<?>) t); } else if (t instanceof ParameterizedType) { ParameterizedType parameterized = (ParameterizedType) t; ret.addAll(getReferencedClasses(Sets.newHashSet(parameterized.getRawType()), settings)); ret.addAll( getReferencedClasses( Sets.newHashSet(Arrays.asList(parameterized.getActualTypeArguments()).iterator()), settings)); } } } return ret; }
/** 获取一个Type类型实际对应的Class */ @SuppressWarnings("rawtypes") public static Class<?> getTypeClass(Type type) { Class<?> clazz = null; if (type instanceof Class<?>) { clazz = (Class<?>) type; } else if (type instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type; clazz = (Class<?>) pt.getRawType(); } else if (type instanceof GenericArrayType) { GenericArrayType gat = (GenericArrayType) type; Class<?> typeClass = getTypeClass(gat.getGenericComponentType()); return Array.newInstance(typeClass, 0).getClass(); } else if (type instanceof TypeVariable) { TypeVariable tv = (TypeVariable) type; Type[] ts = tv.getBounds(); if (ts != null && ts.length > 0) return getTypeClass(ts[0]); } else if (type instanceof WildcardType) { WildcardType wt = (WildcardType) type; Type[] t_low = wt.getLowerBounds(); // 取其下界 if (t_low.length > 0) return getTypeClass(t_low[0]); Type[] t_up = wt.getUpperBounds(); // 没有下界?取其上界 return getTypeClass(t_up[0]); // 最起码有Object作为上界 } return clazz; }
/** * Determines the component type. Lists is the first type, Map is the second type, etc. * * @param type The parametrized type. * @param path The path to the type, used in exception message. * @return The component type. */ public static Type componentType(Type type, String path) { if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; Class<?> rawType = (Class<?>) parameterizedType.getRawType(); if (Map.class.isAssignableFrom(rawType)) { return parameterizedType.getActualTypeArguments()[1]; } else if (Collection.class.isAssignableFrom(rawType)) { return parameterizedType.getActualTypeArguments()[0]; } else { throw new CollectionExpressionException("Unknown collection type [" + type + "]"); } } else if (type instanceof GenericArrayType) { return ((GenericArrayType) type).getGenericComponentType(); } Class<?> rawType = (Class<?>) type; if (Map.class == type || Collection.class == type) { throw new CollectionExpressionException( "The method or member [" + path + "] returns a simple " + "Map or Collection. Unable to determine the type of the Map or Collection. " + "Please make this method generic so that the correct type can be determined."); } else if (rawType.isArray()) { return rawType.getComponentType(); } return rawType; }
static Class<?> getTypeClass(Type type) { if (type instanceof Class<?>) { return (Class<?>) type; } if (type instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type; Class<?> c = (Class<?>) pt.getRawType(); if (ValuedEnum.class.isAssignableFrom(c)) { Type[] types = pt.getActualTypeArguments(); if (types == null || types.length != 1) { c = int.class; } else { c = getTypeClass(pt.getActualTypeArguments()[0]); } } return c; } if (type instanceof GenericArrayType) { if (Object.class.isAssignableFrom( getTypeClass(((GenericArrayType) type).getGenericComponentType()))) { return Object[].class; } } throw new UnsupportedOperationException("Unknown type type : " + type.getClass().getName()); }
private void writeObject( ContentValues values, Object object, String columnName, ParameterizedType fieldType) throws IOException { if (object == null) return; final Type rawType = fieldType.getRawType(); if (!(rawType instanceof Class)) throw new UnsupportedOperationException(); final Class rawCls = (Class) rawType; if (List.class.isAssignableFrom(rawCls)) { values.put( columnName, LoganSquare.serialize((List) object, (Class) fieldType.getActualTypeArguments()[0])); } else if (Map.class.isAssignableFrom(rawCls)) { //noinspection unchecked values.put( columnName, LoganSquare.serialize((Map) object, (Class) fieldType.getActualTypeArguments()[1])); } else if (rawCls.isArray()) { final Class componentType = rawCls.getComponentType(); values.put( columnName, LoganSquare.serialize((List) Arrays.asList((Object[]) object), componentType)); } else { values.put(columnName, LoganSquare.serialize(object)); } }
@SuppressWarnings("unchecked") static Class<? extends Event<?>> getEventClass(Class<?> handlerClass) { for (Class<?> i : handlerClass.getInterfaces()) { if (EventHandler.class.equals(i)) { for (Type t : handlerClass.getGenericInterfaces()) { if (t instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) t; if (EventHandler.class.equals(pt.getRawType())) { return (Class<? extends Event<?>>) pt.getActualTypeArguments()[0]; } } } } else if (EventHandler.class.isAssignableFrom(i)) { return getEventClass((Class<? extends EventHandler<?>>) i); } } if (EventHandler.class.isAssignableFrom(handlerClass.getSuperclass())) { return getEventClass((Class<?>) handlerClass.getSuperclass()); } return null; }
/** * Infer value type in one collection type * * @param genericType * @return */ public static Type inferElementTypeIn(Type collectionType) { if (collectionType instanceof Class) { return Object.class; } else if (collectionType instanceof ParameterizedType) { ParameterizedType parameterizedCollectionType = (ParameterizedType) collectionType; Type collectionValueType = parameterizedCollectionType.getActualTypeArguments()[0]; if (collectionValueType instanceof Class) { return (Class) collectionValueType; } else if (collectionValueType instanceof ParameterizedType) { ParameterizedType type = (ParameterizedType) collectionValueType; return type.getRawType(); } else if (collectionValueType instanceof WildcardType) { throw new UnusableTypeException( "we can't infer element type in widlcard type " + collectionType.toString()); } else if (collectionValueType instanceof TypeVariable) { throw new UnusableTypeException( "we can't infer element type in type variable " + collectionType.toString()); } } else if (collectionType instanceof WildcardType) { throw new UnusableTypeException( "we can't infer element type in widlcard type " + collectionType.toString()); } else if (collectionType instanceof TypeVariable) { throw new UnusableTypeException( "we can't infer element type in type variable " + collectionType.toString()); } throw new UnusableTypeException("we can't infer element type in " + collectionType.toString()); }
private String nameFor(ParameterizedType type) { Class<?> raw = (Class<?>) type.getRawType(); if (Collection.class.isAssignableFrom(raw)) { return nameFor(type.getActualTypeArguments()[0]) + "List"; } return nameFor(raw); }
/** * Creates the type, it's private so you must use fromType. * * @param type */ private JavaType(Type type) { // the type this.type = type; // parameterized? parameterizedType = ParameterizedType.class.isInstance(type) ? ParameterizedType.class.cast(type) : null; // generic info genericInfo = parameterizedType != null; // get class if (Class.class.isInstance(type)) { clazz = Class.class.cast(type); } else if (parameterizedType != null) { clazz = Class.class.cast(parameterizedType.getRawType()); } else { clazz = null; } // component type if (clazz != null && clazz.getComponentType() != null) { componentType = clazz.getComponentType(); } // instantiable instantiable = clazz != null; // typeParameters typeParameters = parameterizedType != null ? parameterizedType.getActualTypeArguments() : null; // genericInfo genericInfo = typeParameters != null; }
private static int checkParameterizedType( String subroutineName, ParameterizedType expectedType, ArgumentsList arguments, List<LispObject> args, int argsCounter, int i) { Type rawType = expectedType.getRawType(); Type expectedTypeArguments = expectedType.getActualTypeArguments()[0]; try { if (((Class) rawType).isInstance(args.get(argsCounter))) { Type actualTypeArguments = ((ParameterizedType) (Type) args.get(argsCounter).getClass()) .getActualTypeArguments()[0]; if (!expectedTypeArguments.equals(actualTypeArguments)) { throw new WrongTypeArgumentException( ((Class) rawType).getSimpleName() + "<" + ((Class) expectedTypeArguments).getSimpleName() + ">", args.get(argsCounter)); } arguments.setValue(i, args.get(argsCounter)); return argsCounter + 1; } else { if (arguments.isOptional(i)) return -1; throw new WrongTypeArgumentException(expectedType.toString(), args.get(argsCounter)); } } catch (IndexOutOfBoundsException e) { if (arguments.isOptional(i)) return -1; throw new WrongNumberOfArgumentsException(subroutineName, i); } }
@SuppressWarnings("unchecked") private static Class<?> getRawType(Type type) { if (type instanceof Class<?>) { // type is a normal class. return (Class<?>) type; } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; // I'm not exactly sure why getRawType() returns Type instead of Class. // Neal isn't either but suspects some pathological case related // to nested classes exists. Type rawType = parameterizedType.getRawType(); if (rawType instanceof Class<?>) { return (Class<?>) rawType; } throw buildUnexpectedTypeError(rawType, Class.class); } else if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type; // TODO(jleitch): This is not the most efficient way to handle generic // arrays, but is there another way to extract the array class in a // non-hacky way (i.e. using String value class names- "[L...")? Object rawArrayType = Array.newInstance(getRawType(genericArrayType.getGenericComponentType()), 0); return rawArrayType.getClass(); } else { throw buildUnexpectedTypeError(type, ParameterizedType.class, GenericArrayType.class); } }
/** * Get the parameterized class arguments for a declaring class that declares a generic interface * type. * * @param p the declaring class * @return the parameterized class arguments, or null if the generic interface type is not a * parameterized type. */ public static Class[] getParameterizedClassArguments(DeclaringClassInterfacePair p) { if (p.genericInterface instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) p.genericInterface; Type[] as = pt.getActualTypeArguments(); Class[] cas = new Class[as.length]; for (int i = 0; i < as.length; i++) { Type a = as[i]; if (a instanceof Class) { cas[i] = (Class) a; } else if (a instanceof ParameterizedType) { pt = (ParameterizedType) a; cas[i] = (Class) pt.getRawType(); } else if (a instanceof TypeVariable) { ClassTypePair ctp = resolveTypeVariable(p.concreteClass, p.declaringClass, (TypeVariable) a); cas[i] = (ctp != null) ? ctp.c : Object.class; } else if (a instanceof GenericArrayType) { cas[i] = getClassOfType(a); } } return cas; } else { return null; } }