/** Finds the parent binder type in the supplied set, if any. */ private @Nullable TypeElement findParentType(TypeElement typeElement, Set<TypeElement> parents) { TypeMirror type; while (true) { type = typeElement.getSuperclass(); if (type.getKind() == TypeKind.NONE) { return null; } typeElement = (TypeElement) ((DeclaredType) type).asElement(); if (parents.contains(typeElement)) { return typeElement; } } }
public void returnTypeIsVoidOrBoolean(ExecutableElement executableElement, ElementValidation valid) { TypeMirror returnType = executableElement.getReturnType(); TypeKind returnKind = returnType.getKind(); if (returnKind != TypeKind.BOOLEAN && returnKind != TypeKind.VOID && !returnType.toString().equals(CanonicalNameConstants.BOOLEAN)) { valid.addError("%s can only be used on a method with a boolean or a void return type"); } }
private ExecutableElement getMethod(List<ExecutableElement> methods, String methodName, String returnType, String... parameterTypes) { for (ExecutableElement method : methods) { List<? extends VariableElement> parameters = method.getParameters(); // Get the method return type or "VOID" if none. String methodReturnType = method.getReturnType().getKind() == TypeKind.VOID ? TypeKind.VOID.toString() : method.getReturnType().toString(); if (parameters.size() == parameterTypes.length && methodReturnType.equals(returnType)) { if (methodName == null || method.getSimpleName().toString().equals(methodName)) { // At this point, method name, return type and number of // parameters are correct. Now we need to validate the // parameter types. boolean validMethod = true; for (int i = 0; i < parameters.size(); i++) { VariableElement param = parameters.get(i); if (!param.asType().toString().equals(parameterTypes[i])) { // Parameter type does not match, this is not the // correct method. validMethod = false; break; } } if (validMethod) { return method; } } } } return null; }
private TypeMirror getEntityOrIdType(Element element, int index) { if (isSubtypeOfDao(element.asType())) { DeclaredType declaredType = (DeclaredType) element.asType(); List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() == 2) { return typeArguments.get(index); } } List<? extends TypeMirror> superTypes = helper.directSupertypes(element.asType()); for (TypeMirror superType : superTypes) { if (superType.getKind() == TypeKind.DECLARED && isSubtypeOfDao(superType)) { DeclaredType superDeclaredType = (DeclaredType) superType; List<? extends TypeMirror> typeArguments = superDeclaredType.getTypeArguments(); if (typeArguments.size() == 2) { return typeArguments.get(index); } } } return null; }
return true; if (typeMirror.getKind() != TypeKind.DECLARED) { return false; if (typeArguments.size() > 0) { StringBuilder typeString = new StringBuilder(declaredType.asElement().toString()); typeString.append('<'); for (int i = 0; i < typeArguments.size(); i++) { if (i > 0) { typeString.append(','); Element element = declaredType.asElement(); if (!(element instanceof TypeElement)) { return false;
public static void validateSwipeTouch(ExecutableElement element) throws IllegalUseException { validateNonPrivateModifier(element); if (element.getParameters().size() != 4) { String msg = "@SwipeTouch must be used on the method with (float, float, float, float) signature"; throw new IllegalUseException(msg); } for (VariableElement variableElement : element.getParameters()) { if (variableElement.asType().getKind() != TypeKind.FLOAT) { String msg = "@SwipeTouch used with method that do not have all 4 float parameters"; throw new IllegalUseException(msg); } } }
element = ((ExecutableElement) element).getParameters().get(0); type = element.asType(); if (type instanceof ErrorType || type.getKind() == TypeKind.ERROR) { String elementTypeName = type.toString();
public IJExpression getResponseClass(Element element, RestHolder holder) { ExecutableElement executableElement = (ExecutableElement) element; IJExpression responseClassExpr = nullCastedToNarrowedClass(holder); TypeMirror returnType = executableElement.getReturnType(); if (returnType.getKind() != TypeKind.VOID) { if (getElementUtils().getTypeElement(RestSpringClasses.PARAMETERIZED_TYPE_REFERENCE) != null) { if (returnType.toString().startsWith(RestSpringClasses.RESPONSE_ENTITY)) { List<? extends TypeMirror> typeArguments = ((DeclaredType) returnType).getTypeArguments(); if (!typeArguments.isEmpty()) { returnType = typeArguments.get(0); } } if (checkIfParameterizedTypeReferenceShouldBeUsed(returnType)) { return createParameterizedTypeReferenceAnonymousSubclassInstance(returnType); } } AbstractJClass responseClass = retrieveResponseClass(returnType, holder); if (responseClass != null) { responseClassExpr = responseClass.dotclass(); } } return responseClassExpr; }
private TypeMirror createStringTypeMirror() { TypeElement element = typeElement; while (element.getSuperclass().getKind() != TypeKind.NONE) { logger.finest("finding toString in " + element); element = (TypeElement) ((DeclaredType) element.getSuperclass()).asElement(); } for (Element enclosed : typeElement.getEnclosedElements()) { if (enclosed.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) enclosed; if (method.getSimpleName().contentEquals("toString")) { return method.getReturnType(); } } } throw new IllegalStateException("Cannot find toString method in Object"); } private static boolean find(String interfaceName, TypeElement typeElement) {
if (enclosedElement.getKind() != ElementKind.METHOD) { return ImmutableList.of(); && methodElement.getReturnType().getKind() == TypeKind.VOID;
/** * Return true if the possibleBuilderMethod matches the * Style#attributeBuilder() and returns a class. * * TODO: may need to make this return true if the return type is an interface too... * * @param possibleBuilderMethod executableElement */ private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) { if (possibleBuilderMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderMethod.getSimpleName())) { return false; } ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod; TypeKind kind = candidateMethod.getReturnType().getKind(); return possibleBuilderMethod.getModifiers().containsAll( Arrays.asList(Modifier.STATIC, Modifier.PUBLIC)) && candidateMethod.getParameters().isEmpty() && candidateMethod.getReturnType().getKind() == TypeKind.DECLARED && !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) { if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) { return false; } ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod; return candidateConstructor.getModifiers().contains(Modifier.PUBLIC) && candidateConstructor.getTypeParameters().isEmpty(); } return false; }
private boolean isSimpleAccessor(ExecutableElement method) { return method.getParameters().isEmpty() && method.getThrownTypes().isEmpty() && method.getTypeParameters().isEmpty() && method.getReturnType().getKind() != TypeKind.VOID; }
private void debugElement(Element element, String s) { logger.finest(format(s + ": kind=%s, cls=%s, simpleName=%s, type=%s, typeKind=%s, enclosed=%s, enclosing=%s", element.getKind(), element.getClass().getName(), element.getSimpleName(), element.asType(), element.asType().getKind(), element.getEnclosedElements(), element.getEnclosingElement())); TypeMirror typeMirror = element.asType(); if (element.getKind() == ENUM) { for (Element enclosed : element.getEnclosedElements()) { debugElement(enclosed, s + " "); } } else { debugType(typeMirror, element, s + " "); } }
public void hasSeekBarProgressChangeMethodParameters(ExecutableElement executableElement, ElementValidation valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); boolean seekBarParameterFound = false; boolean fromUserParameterFound = false; continue; if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { if (progressParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.INTEGER); continue; if (parameter.asType().getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType)) { if (fromUserParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.BOOLEAN);
/** * Get information about methods returning class type of the original class so we can duplicate * them in the generated class for chaining purposes */ protected void collectMethodsReturningClassType(TypeElement modelClass, Types typeUtils) { TypeElement clazz = modelClass; while (clazz.getSuperclass().getKind() != TypeKind.NONE) { for (Element subElement : clazz.getEnclosedElements()) { Set<Modifier> modifiers = subElement.getModifiers(); if (subElement.getKind() == ElementKind.METHOD && !modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.FINAL) && !modifiers.contains(Modifier.STATIC)) { TypeMirror methodReturnType = ((ExecutableType) subElement.asType()).getReturnType(); if (methodReturnType.equals(clazz.asType()) || typeUtils.isSubtype(clazz.asType(), methodReturnType)) { ExecutableElement castedSubElement = ((ExecutableElement) subElement); List<? extends VariableElement> params = castedSubElement.getParameters(); String methodName = subElement.getSimpleName().toString(); if (methodName.equals(RESET_METHOD) && params.isEmpty()) { continue; } methodsReturningClassType.add(new MethodInfo(methodName, modifiers, buildParamSpecs(params), castedSubElement.isVarArgs())); } } } clazz = (TypeElement) typeUtils.asElement(clazz.getSuperclass()); } }
public static String getGetter(Element element, Elements elements) { TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); TypeKind elementTypeKind = element.asType().getKind(); List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) { if (methodElement.getParameters().size() == 0) { String methodNameString = methodElement.getSimpleName().toString(); String methodNameLowerCase = methodNameString.toLowerCase(); if (methodElement.getParameters().size() == 0) { if (methodElement.getReturnType().toString().equals(element.asType().toString())) { return methodNameString;
if (clazz.getSuperclass().getKind() != TypeKind.DECLARED) { return null; getEpoxyObjectType((TypeElement) typeUtils.asElement(superclass), typeUtils); if (recursiveResult != null && recursiveResult.getKind() != TypeKind.TYPEVAR) { if (superTypeArguments.size() == 1) { return superTypeArguments.get(0);
return true; if (typeMirror.getKind() != TypeKind.DECLARED) { return false; if (typeArguments.size() > 0) { StringBuilder typeString = new StringBuilder(declaredType.asElement().toString()); typeString.append('<'); for (int i = 0; i < typeArguments.size(); i++) { if (i > 0) { typeString.append(','); Element element = declaredType.asElement(); if (!(element instanceof TypeElement)) { return false;