/** * Check if the given class or any of its super classes have a super method with the given name. * Private methods are ignored since the generated subclass can't call super on those. */ protected boolean hasSuperMethod(TypeElement classElement, Element attribute) { if (!Utils.isEpoxyModel(classElement.asType())) { return false; } for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) subElement; if (!method.getModifiers().contains(Modifier.PRIVATE) && method.getSimpleName().toString().equals(attribute.getSimpleName().toString()) && method.getParameters().size() == 1 && method.getParameters().get(0).asType().equals(attribute.asType())) { return true; } } } Element superClass = typeUtils.asElement(classElement.getSuperclass()); return (superClass instanceof TypeElement) && hasSuperMethod((TypeElement) superClass, attribute); }
public RInnerClass(TypeElement rInnerTypeElement) { if (rInnerTypeElement != null) { rInnerQualifiedName = rInnerTypeElement.getQualifiedName().toString(); List<? extends Element> idEnclosedElements = rInnerTypeElement.getEnclosedElements(); List<VariableElement> idFields = ElementFilter.fieldsIn(idEnclosedElements); for (VariableElement idField : idFields) { TypeKind fieldType = idField.asType().getKind(); if (fieldType.isPrimitive() && fieldType.equals(TypeKind.INT)) { String idQualifiedName = rInnerQualifiedName + "." + idField.getSimpleName(); idQualifiedNames.add(idQualifiedName); Integer idFieldId = (Integer) idField.getConstantValue(); if (idFieldId != null) { idQualifiedNamesByIdValues.put(idFieldId, idQualifiedName); } } } } else { rInnerQualifiedName = ""; } }
private void debugMethod(ExecutableElement method) { logger.finest(format(" method: simpleName=%s, asType=%s, varargs=%s, returnType=%s, enclosingElement=%s, params=%s, typeParams=%s", method.getSimpleName(), method.asType(), method.isVarArgs(), method.getReturnType(), method.getEnclosingElement(), method.getParameters(), method.getTypeParameters())); for (VariableElement variable : method.getParameters()) { logger.finest(format(" variable: name=%s, annotationMirrors=%s, @Option=%s, @Parameters=%s", variable.getSimpleName(), variable.getAnnotationMirrors(), variable.getAnnotation( Option.class), variable.getAnnotation(Parameters.class))); } }
public JVar getEntitySentToServer(ExecutableElement element, SortedMap<String, JVar> params) { for (VariableElement parameter : element.getParameters()) { if (parameter.getAnnotation(Body.class) != null) { return params.get(parameter.getSimpleName().toString()); } } return null; }
private static String getSmartPrimitiveParameterName(VariableElement parameter) { for (AnnotationMirror annotation : parameter.getAnnotationMirrors()) { String annotationName = annotation.getAnnotationType().toString().toUpperCase(); if (annotationName.endsWith("RES")) { // Catch annotations like StringRes return "id"; } else if (annotationName.endsWith("RANGE")) { // Catch annotations like IntRange return "value"; } } return parameter.getSimpleName().toString(); }
private String fieldFullName( VariableElement field ) { return String.format( "%s#%s", field.getEnclosingElement().getSimpleName(), field.getSimpleName() ); }
@Override public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { String methodName = element.getSimpleName().toString(); List<? extends VariableElement> parameters = executableElement.getParameters(); TypeMirror parameterType = parameter.asType(); if (CanonicalNameConstants.EDITABLE.equals(parameterType.toString())) { editableParameterPosition = i; } else { TypeMirror textViewType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); if (annotationHelper.isSubtype(parameterType, textViewType)) { viewParameterPosition = i;
throws Exception { if (!(element instanceof ExecutableElement) || element.getKind() != METHOD) { throw new IllegalStateException( String.format("@%s annotation must be on a method.", annotationClass.getSimpleName())); TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); Annotation annotation = element.getAnnotation(annotationClass); Method annotationValue = annotationClass.getDeclaredMethod("value"); if (annotationValue.getReturnType() != int[].class) { String name = executableElement.getSimpleName().toString(); boolean required = isListenerRequired(executableElement); annotationClass.getSimpleName(), id, enclosingElement.getQualifiedName(), for (int i = 0; i < methodParameters.size(); i++) { VariableElement methodParameter = methodParameters.get(i); TypeMirror methodParameterType = methodParameter.asType(); if (methodParameterType instanceof TypeVariable) { TypeVariable typeVariable = (TypeVariable) methodParameterType; .append(j + 1) .append(": ") .append(methodParameters.get(j).asType().toString()) .append("\n "); if (parameter == null) {
if (enclosedElement.getKind() != ElementKind.METHOD) { valid.addError(enclosedElement, "Only methods are allowed in a %s annotated interface"); } else { TypeMirror returnType = executableElement.getReturnType(); String simpleName = executableElement.getSimpleName().toString(); if (!returnType.toString().equals(CanonicalNameConstants.STRING)) { valid.addError(enclosedElement, "The method getRootUrl must return String on a %s annotated interface"); valid.addError(enclosedElement, "The can be only one getRootUrl method on a %s annotated interface"); } else if (returnType.getKind() == TypeKind.VOID) { VariableElement firstParameter = parameters.get(0); if (firstParameter.asType().toString().equals(REST_TEMPLATE)) { if (!foundSetRestTemplateMethod) { foundSetRestTemplateMethod = true; VariableElement firstParameter = parameters.get(0); VariableElement secondParameter = parameters.get(1); if (!(firstParameter.asType().toString().equals(CanonicalNameConstants.STRING) && secondParameter.asType().toString().equals(CanonicalNameConstants.STRING))) { valid.addError(enclosedElement, "The method to set headers, cookies, or HTTP Basic Auth should have only String parameters on a " + TargetAnnotationHelper.annotationName(Rest.class) + " annotated interface"); if (parameters.size() == 1) { VariableElement firstParameter = parameters.get(0); if (firstParameter.asType().toString().equals(CanonicalNameConstants.STRING)) {
Element possibleCopyMethod, boolean onValueType) { if (possibleCopyMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleCopyMethod.getSimpleName())) { return false; .getTypeUtils(); if (candidateCopyMethod.getParameters().size() == 1 && typeUtils.isSameType( candidateCopyMethod.getParameters().get(0).asType(), valueAttribute.containedTypeElement.asType())) { TypeKind kind = candidateCopyMethod.getReturnType().getKind(); return !kind.isPrimitive() && kind != TypeKind.ARRAY; && !candidateCopyMethod.getModifiers().contains(Modifier.STATIC)) { TypeKind kind = candidateCopyMethod.getReturnType().getKind(); return !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleCopyMethod.getKind() == ElementKind.CONSTRUCTOR) { return candidateConstructor.getParameters().size() == 1 && candidateConstructor.getParameters().get(0).asType().equals(valueAttribute.containedTypeElement.asType());
public EntityType handleEntityType(TypeElement element) { EntityType entityType = typeFactory.getEntityType(element.asType(), true); List<? extends Element> elements = element.getEnclosedElements(); VisitorConfig config = configuration.getConfig(element, elements); Set<String> blockedProperties = new HashSet<String>(); for (VariableElement field : ElementFilter.fieldsIn(elements)) { String name = field.getSimpleName().toString(); if (configuration.isBlockedField(field)) { blockedProperties.add(name); Annotations annotations = new Annotations(); configuration.inspect(field, annotations); annotations.addAnnotation(field.getAnnotation(QueryType.class)); annotations.addAnnotation(field.getAnnotation(QueryInit.class)); propertyAnnotations.put(name, annotations); propertyTypes.put(name, field.asType()); TypeMirror fixedType = configuration.getRealType(field); if (fixedType != null) { for (ExecutableElement method : ElementFilter.methodsIn(elements)) { String name = method.getSimpleName().toString(); if (name.startsWith("get") && name.length() > 3 && method.getParameters().isEmpty()) { name = BeanUtils.uncapitalize(name.substring(3)); } else if (name.startsWith("is") && name.length() > 2 && method.getParameters().isEmpty()) { name = BeanUtils.uncapitalize(name.substring(2)); } else {
private void validate() { final Map<String, Set<TypeMirror>> fields = new HashMap<>(); final Map<String, Set<TypeMirror>> methods = new HashMap<>(); final TypeElement e = (TypeElement) types.asElement(resultType); for (ExecutableElement executableElement : ElementFilter.methodsIn(elements.getAllMembers(e))) { if (executableElement.getModifiers().contains(Modifier.PUBLIC) && executableElement.getParameters().size() == 1) { final String methodName = executableElement.getSimpleName().toString(); types.add(executableElement.getParameters().get(0).asType()); for (Element element : ElementFilter.fieldsIn(elements.getAllMembers(e))) { if (element.getModifiers().contains(Modifier.PUBLIC) && !element.getModifiers().contains(Modifier.FINAL)) { final Set<TypeMirror> types = fields.computeIfAbsent(element.getSimpleName().toString(), (key -> new HashSet<>())); types.add(element.asType());
TypeName typeName = TypeName.get(parameter.asType()); if (mContext.equals(typeName)) { if (paramBuild.length() > 0) paramBuild.append(", "); RequestHeader requestHeader = parameter.getAnnotation(RequestHeader.class); if (requestHeader != null) { Validate.isTrue(isBasicType(typeName), CookieValue cookieValue = parameter.getAnnotation(CookieValue.class); if (cookieValue != null) { Validate.isTrue(mString.equals(typeName), "CookieValue can only be used with [String] on %s.", PathVariable pathVariable = parameter.getAnnotation(PathVariable.class); if (pathVariable != null) { Validate.isTrue(isBasicType(typeName), QueryParam queryParam = parameter.getAnnotation(QueryParam.class); if (queryParam != null) { Validate.isTrue(isBasicType(typeName), RequestParam requestParam = parameter.getAnnotation(RequestParam.class); if (requestParam != null) { boolean valid = mMultipart.equals(typeName) || isBasicType(typeName); FormPart formPart = parameter.getAnnotation(FormPart.class); if (formPart != null) { String name = formPart.name(); RequestBody requestBody = parameter.getAnnotation(RequestBody.class);
private void addMethods(TypeElement interfaceClazz, TypeSpec.Builder classBuilder) { List<? extends Element> elements = interfaceClazz.getEnclosedElements(); if (elements != null && !elements.isEmpty()) { for (Element e : elements) { if (ElementKind.METHOD.equals(e.getKind())) { ExecutableElement method = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getSimpleName().toString() + ASYNC) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT).returns(ResponseFuture.class) .addTypeVariables(getTypeNames(method.getTypeParameters())); // add method params List<? extends VariableElement> vars = method.getParameters(); for (VariableElement var : vars) { methodBuilder.addParameter(ParameterSpec.builder(TypeName.get(var.asType()), var.getSimpleName().toString()) .build()); } classBuilder.addMethod(methodBuilder.build()); } } } }
public static Set<Parameter> of(final ProcessingEnvironment processingEnv, final ExecutableElement method) { final Types types = processingEnv.getTypeUtils(); final Set<Parameter> result = new LinkedHashSet<>(); final List<? extends VariableElement> params = method.getParameters(); int index = 0; for (VariableElement param : params) { final TypeElement formatClassType = ElementHelper.getClassAnnotationValue(param, FormatWith.class); final String formatClass = formatClassType == null ? null : formatClassType.getQualifiedName().toString(); final String qualifiedType; if (param.asType().getKind().isPrimitive()) { qualifiedType = param.asType().toString(); } else { switch ((param.asType().getKind())) { case ARRAY: qualifiedType = param.asType().toString().replace("[]", ""); break; default: qualifiedType = types.asElement(param.asType()).toString(); break; } } if (method.isVarArgs()) { result.add(new AptParameter(processingEnv, qualifiedType, param, formatClass, (++index == params.size()))); } else { result.add(new AptParameter(processingEnv, qualifiedType, param, formatClass, false)); } } return result; }
private void processFromProperties(TypeElement type, Set<TypeElement> types) { List<? extends Element> children = type.getEnclosedElements(); VisitorConfig config = conf.getConfig(type, children); // fields if (config.visitFieldProperties()) { for (VariableElement field : ElementFilter.fieldsIn(children)) { TypeElement typeElement = typeExtractor.visit(field.asType()); if (typeElement != null) { types.add(typeElement); } } } // getters if (config.visitMethodProperties()) { for (ExecutableElement method : ElementFilter.methodsIn(children)) { String name = method.getSimpleName().toString(); if ((name.startsWith("get") || name.startsWith("is")) && method.getParameters().isEmpty()) { TypeElement typeElement = typeExtractor.visit(method.getReturnType()); if (typeElement != null) { types.add(typeElement); } } } } }
if (TypeName.get(executableElement.getReturnType()).toString().contains(DATA_ARR_CLASS)) {//返回列表数据 methodBuilder.returns(ClassName.get("io.reactivex", "Flowable")); Map<String, Object> params = new HashMap<>(); ClassName C = ClassName.get("com", "C"); CodeBlock.Builder blockBuilder = CodeBlock.builder(); int len = executableElement.getParameters().size(); for (int i = 0; i < len; i++) { VariableElement ep = executableElement.getParameters().get(i); boolean isLast = i == len - 1; String split = (isLast ? "" : ","); switch (ep.getSimpleName().toString()) { case "include": blockBuilder.add("$L.getInclude(param)" + split, apiUtil); ".compose($T.io_main())" , ClassName.get("com.api", "Api") , e.getSimpleName().toString() , blockBuilder.build().toString() , ClassName.get("com.base.util.helper", "RxSchedulers")); methodBuilder.addParameter(TypeName.get(ep.asType()), ep.getSimpleName().toString()); paramsString += ep.getSimpleName().toString() + ",";
private void handleBaseBuilder() { if (!MoreTypes.isTypeOf(Object.class, baseBuilder.asType())) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(baseBuilder.getEnclosedElements()); Optional<ExecutableElement> constructor = constructors.stream().filter(c -> c.getParameters().size() == 0).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), false)); } else { constructor = constructors.stream().filter(c -> c.getParameters().size() == 1 && Types.CONTEXT.equals(TypeName.get(c.getParameters().get(0).asType()))).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), true)); } else { final AnnotationMirror mirror = baseAnnotation.getAnnotationMirrors().stream() .filter(m -> MoreTypes.isTypeOf(Configuration.class, m.getAnnotationType())) .findAny().orElseThrow(IllegalArgumentException::new); messager.printMessage(Diagnostic.Kind.ERROR, "Classes used as base builder must have a constructor which takes no arguments, " + "or exactly one argument of type Class", baseAnnotation, mirror, mirror.getElementValues().entrySet().stream() .filter(entry -> entry.getKey().getSimpleName().toString().equals("builderSuperClass")).findAny().map(Map.Entry::getValue).orElse(null)); throw new IllegalArgumentException(); } } handleBaseBuilderMethods(); } }
private boolean hasActivityOptions(TypeElement type, int optionsParamPosition) { if (type == null) { return false; } for (ExecutableElement element : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) { if (element.getSimpleName().contentEquals("startActivity")) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == optionsParamPosition + 1) { VariableElement parameter = parameters.get(optionsParamPosition); if (parameter.asType().toString().equals(CanonicalNameConstants.BUNDLE)) { return true; } } } } return false; }
if (!type.getKind().isPrimitive() && type.getKind() != TypeKind.VOID) { final Element element = types.asElement(type); final List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); for (ExecutableElement constructor : constructors) { if (!constructor.getModifiers().contains(Modifier.PUBLIC)) { continue; final List<? extends VariableElement> params = constructor.getParameters(); switch (params.size()) { case 0: break; case 1: if (types.isAssignable(stringType, params.get(0).asType())) { stringConstructor = true; } else if (types.isAssignable(params.get(0).asType(), throwableType)) { throwableConstructor = true; if (types.isAssignable(stringType, params.get(0).asType()) && types.isAssignable(params.get(1).asType(), throwableType)) { stringAndThrowableConstructor = true; } else if (types.isAssignable(params.get(0).asType(), throwableType) && types.isAssignable(stringType, params.get(1).asType())) { throwableAndStringConstructor = true;