public static Class<?> getActualTypeArgument(Class<?> declaringClass, Type genericType) { if(null == declaringClass) { return getActualTypeArgument(genericType); }else{ return getActualType(declaringClass, getTypeArgument(genericType)); } }
public static TypeInfo getTypeInfo(Class<?> type,Type genericType) { MTypeKind kind = null; Class<?> elementType = null; TypeInfo elementTypeInfo = null; if(isSimpleType(type, genericType)){ kind = MTypeKind.SIMPLE; }else if(isCollectionType(type, genericType)){ kind = MTypeKind.COLLECTION; elementType = getElementType(type, genericType); elementTypeInfo = getTypeInfo(elementType, null); }else{ kind = MTypeKind.COMPLEX; } return new TypeInfo(type, genericType, kind,elementType,elementTypeInfo); }
Class<?> superClass = getRawType(superType); if (!isAssignable(cls, superClass)) { return null; return getTypeArguments(superType, superClass, null); Type midType = getClosestParentType(cls, superClass); return determineTypeArguments((Class<?>) midType, superType); Class<?> midClass = getRawType(midParameterizedType); Map<TypeVariable<?>, Type> typeVarAssigns = determineTypeArguments(midClass, superType); mapTypeVariablesToArguments(cls, midParameterizedType, typeVarAssigns);
public static Class<?>[] getActualTypeArguments(Type genericType){ return getActualTypes(getTypeArguments(genericType)); }
Classes.isAnnotationPresent(annotations, R.class); Type typeArgument = Types.getTypeArgument(genericType); Class<?> acturalTypeArgument = Types.getActualType(typeArgument); beanType = Types.getActualTypeArgument(typeArgument); beanType = Types.getActualTypeArgument(genericType); Type[] types = Types.getTypeArguments(genericType); if(types.length != 2) { return null; beanType = Types.getActualType(types[1]);
public PartialImpl(Map m,Type genericType) throws IllegalAccessException, InstantiationException { this.m = m; if(genericType != null){ clzz = (Class<T>)Types.getActualTypeArgument(genericType); }else{ clzz = null; } }
if(type instanceof GenericArrayType){ java.lang.reflect.Type componentType = ((GenericArrayType) type).getGenericComponentType(); Type elementType = Types.getTypeArgument(componentType); if(elementType == Object.class){ return false; .filter(cls -> Types.isAssignable(cls,elementType) && cls != elementType) .toArray(length -> new Class<?>[length]); value.ok(values); if(List.class.isAssignableFrom(v.getType()) && Class.class.isAssignableFrom(Types.getActualTypeArgument(v.getGenericType()))){ java.lang.reflect.Type elementType = v.getGenericType(); if(elementType instanceof ParameterizedType){ java.lang.reflect.Type actualClass = ((ParameterizedType) elementType).getActualTypeArguments()[0]; java.lang.reflect.Type classType = Types.getTypeArgument(actualClass); if(elementType == Object.class){ return false; .filter(cls -> Types.isAssignable(cls,classType) && cls != classType) .collect(Collectors.toList()); value.ok(values);
public static Class<?> getElementType(Class<?> type, Type genericType) throws IllegalStateException { if(!isCollectionType(type, genericType)){ throw new IllegalStateException("The given type '" + type + "' is not a collection type"); } if(type.isArray()){ return type.getComponentType(); } if(null == genericType){ return Object.class; } return Types.getActualTypeArgument(genericType); }
return getTypeArguments((Class<?>) type, toClass, subtypeVarAssigns); return getTypeArguments((ParameterizedType) type, toClass, subtypeVarAssigns); return getTypeArguments(((GenericArrayType) type).getGenericComponentType(), toClass.isArray() ? toClass.getComponentType() : toClass, subtypeVarAssigns); for (Type bound : getImplicitUpperBounds((WildcardType) type)) { if (isAssignable(bound, toClass)) { return getTypeArguments(bound, toClass, subtypeVarAssigns); for (Type bound : getImplicitBounds((TypeVariable<?>) type)) { if (isAssignable(bound, toClass)) { return getTypeArguments(bound, toClass, subtypeVarAssigns);
Class<?> cls = getRawType(parameterizedType); if (!isAssignable(cls, toClass)) { return null; typeVarAssigns = getTypeArguments(parameterizedOwnerType, getRawType(parameterizedOwnerType), subtypeVarAssigns); } else { return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
public static Class<?> getActualTypeArgument(Type genericType) { Type type = getTypeArgument(genericType); return type == Object.class ? Object.class : getActualType(type);
Type[] toUpperBounds = getImplicitUpperBounds(toWildcardType); Type[] toLowerBounds = getImplicitLowerBounds(toWildcardType); Type[] upperBounds = getImplicitUpperBounds(wildcardType); Type[] lowerBounds = getImplicitLowerBounds(wildcardType); toBound = substituteTypeVariables(toBound, typeVarAssigns); if (!isAssignable(bound, toBound, typeVarAssigns)) { return false; toBound = substituteTypeVariables(toBound, typeVarAssigns); if (!isAssignable(toBound, bound, typeVarAssigns)) { return false; if (!isAssignable(type, substituteTypeVariables(toBound, typeVarAssigns), typeVarAssigns)) { return false; if (!isAssignable(substituteTypeVariables(toBound, typeVarAssigns), type, typeVarAssigns)) { return false;
public static TypeInfo getTypeInfo(Class<?> type) { return getTypeInfo(type, null); }
Class<?> toClass = getRawType(toParameterizedType); Map<TypeVariable<?>, Type> fromTypeVarAssigns = getTypeArguments(type, toClass, null); Map<TypeVariable<?>, Type> toTypeVarAssigns = getTypeArguments(toParameterizedType, toClass, typeVarAssigns); && !(toTypeArg instanceof WildcardType && isAssignable(fromTypeArg, toTypeArg, typeVarAssigns))) { return false;
if (!isAssignable(cls, toClass)) { return null; return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
protected static Map doConvert(ConvertContext context, Map from, Class<?> targetType, Type genericType) { Type[] typeArguments = Types.getTypeArguments(genericType); Class<?> keyType = Types.getActualType(typeArguments[0]); Class<?> valType = Types.getActualType(typeArguments[1]); Map to = createMap(targetType); for(Object o : from.entrySet()){ Entry entry = (Entry)o; Object key = Converts.convert(entry.getKey(), keyType, typeArguments[0], context); Object val = Converts.convert(entry.getValue(), valType, typeArguments[1], context); to.put(key,val); } return to; }
@Override public MType getMType(Class<?> declaringClass, Class<?> type, Type genericType, MTypeContext context) { Args.notNull(context.root(), "Root factory must be exists!"); if(Types.isSimpleType(type,genericType) || Types.isCollectionType(type,genericType)) { return null; } for(OrmContext c : ormContexts) { EntityMapping em = c.getMetadata().tryGetEntityMapping(type); if(null != em) { return getMType(type, context, c, em); } } return null; }
@Override public boolean resolveInjectValue(BeanDefinition bd, Object bean, ReflectValued v, Annotation a, Out<Object> value) { if(!(v.getType().equals(Dyna.class) || v.getType().equals(Dao.class))) { return false; } if(!bd.isPrimary()) { return false; } if (v.getType().equals(Dao.class)) { value.set(dao); return true; } Class<?>[] types = Types.getActualTypeArguments(v.getGenericType()); if (types.length != 1) { return false; } Class<?> type = types[0]; if (type.equals(Dao.class)) { value.set(dao); return true; } return false; }
return cls.isArray() && isAssignable(cls.getComponentType(), toComponentType, typeVarAssigns); return isAssignable(((GenericArrayType) type).getGenericComponentType(), toComponentType, typeVarAssigns); for (Type bound : getImplicitUpperBounds((WildcardType) type)) { if (isAssignable(bound, toGenericArrayType)) { return true; for (Type bound : getImplicitBounds((TypeVariable<?>) type)) { if (isAssignable(bound, toGenericArrayType)) { return true;
midClass = getRawType((ParameterizedType) midType); } else if (midType instanceof Class<?>) { midClass = (Class<?>) midType; if (isAssignable(midClass, superClass) && isAssignable(genericInterface, (Type) midClass)) { genericInterface = midType;