public static TypeUse createParamTypeUse(ProcessingEnvironment env, ExecutableElement[] methods, int index) { TypeInternal[] internals = new TypeInternal[methods.length]; for (int i = 0;i < methods.length;i++) { for (TypeInternalProvider provider : providers) { internals[i] = provider.forParam(env, methods[i], index); if (internals[i] != null) { break; } } } return new TypeUse(internals); }
public TypeInfo create(TypeUse use, DeclaredType type) { boolean nullable = use != null && use.isNullable(); TypeElement elt = (TypeElement) type.asElement(); PackageElement pkgElt = elementUtils.getPackageOf(elt); typeArguments = new ArrayList<>(typeArgs.size()); for (int i = 0; i < typeArgs.size(); i++) { TypeUse argUse = use != null ? use.getArg(fqcn, i) : null; TypeInfo typeArgDesc = create(argUse, typeArgs.get(i));
public TypeInfo create(TypeUse use, TypeMirror type) { switch (type.getKind()) { case VOID: return VoidTypeInfo.INSTANCE; case ERROR: case DECLARED: return create(use, (DeclaredType) type); case DOUBLE: case LONG: case FLOAT: case CHAR: case BYTE: case SHORT: case BOOLEAN: case INT: if (use != null && use.isNullable()) { throw new IllegalArgumentException("Primitive types cannot be annotated with @Nullable"); } return PrimitiveTypeInfo.PRIMITIVES.get(type.getKind().name().toLowerCase()); case TYPEVAR: return create(use, (TypeVariable) type); case ARRAY: return create(use, (ArrayType) type); default: throw new IllegalArgumentException("Illegal type " + type + " of kind " + type.getKind()); } }
TypeMirror type = methodType.getParameterTypes().get(i); TypeInfo typeInfo; TypeUse typeUse = TypeUse.createParamTypeUse(env, modelMethods.toArray(new ExecutableElement[modelMethods.size()]), i); try { typeInfo = typeFactory.create(typeUse, type);
TypeUse returnTypeUse = TypeUse.createReturnTypeUse(env, modelMethods.toArray(new ExecutableElement[modelMethods.size()]));
public ArrayTypeInfo create(TypeUse use, ArrayType type) { TypeMirror componentType = type.getComponentType(); return new ArrayTypeInfo(create(componentType), use != null && use.isNullable()); }
public TypeVariableInfo create(TypeUse use, TypeVariable type) { TypeParameterElement elt = (TypeParameterElement) type.asElement(); TypeParamInfo param = TypeParamInfo.create(elt); return new TypeVariableInfo(param, use != null && use.isNullable(), elt.getSimpleName().toString()); }
public static TypeUse createReturnTypeUse(ProcessingEnvironment env, ExecutableElement... methods) { TypeInternal[] internals = new TypeInternal[methods.length]; for (int i = 0;i < methods.length;i++) { for (TypeInternalProvider provider : providers) { internals[i] = provider.forReturn(env, methods[i]); if (internals[i] != null) { break; } } } return new TypeUse(internals); }
/** * Return the type use of a type argument of the underlying type. * * @param rawName the name of the raw type for which we want to get the argument * @param index the argument index * @return the type use */ public TypeUse getArg(String rawName, int index) { List<TypeInternal> abc = new ArrayList<>(); for (TypeInternal type : types) { if (!rawName.equals(type.rawName())) { break; } abc.add(type.getArgAt(index)); } return new TypeUse(abc.toArray(new TypeInternal[abc.size()])); }