Refine search
@NonNull @Override public CodeBlock visitEnumConstant(@NonNull VariableElement c, Void v) { return CodeBlock.of("$T.$L", c.asType(), c.getSimpleName()); }
@Override public Builder visitEnumConstant(VariableElement c, String name) { return builder.addMember(name, "$T.$L", c.asType(), c.getSimpleName()); }
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
private Stream<CompilationMessage> validateFieldType( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream() .filter( element -> !element.getModifiers().contains( STATIC ) ) .filter( element -> !fieldTypeVisitor.visit( element.asType() ) ) .map( element -> new RecordTypeError( element, "Record definition error: type of field %s#%s is not supported", recordElement.getSimpleName(), element.getSimpleName() ) ); }
@NonNull public Element fromBuilderDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
@Override public Void visitEnumConstant(VariableElement c, String p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(c.asType()); JEnumConstantRef ref = JExpr.enumConstantRef(annotationClass, c.getSimpleName().toString()); use.param(p, ref); return null; }
@Override public Void visitEnumConstant(VariableElement c, JAnnotationArrayMember p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(c.asType()); JEnumConstantRef ref = JExpr.enumConstantRef(annotationClass, c.getSimpleName().toString()); p.param(ref); return null; }
private Long findSerialVersionUID() { for (VariableElement field : ElementFilter.fieldsIn(element.getEnclosedElements())) { if (field.getSimpleName().contentEquals(SERIAL_VERSION_FIELD_NAME) && field.asType().getKind() == TypeKind.LONG) { return (Long) field.getConstantValue(); } } return null; }
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 = ""; } }
protected SortedMap<String, JVar> addMethodParams(ExecutableElement executableElement, RestHolder restHolder, JMethod method) { List<? extends VariableElement> params = executableElement.getParameters(); SortedMap<String, JVar> methodParams = new TreeMap<>(); for (VariableElement parameter : params) { String paramName = parameter.getSimpleName().toString(); String paramType = parameter.asType().toString(); JVar param; if (parameter.asType().getKind().isPrimitive()) { param = method.param(getCodeModel().parseType(paramType), paramName); } else { AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType()); param = method.param(parameterClass, paramName); } methodParams.put(paramName, param); } return methodParams; }
public static ParameterSpec get(VariableElement element) { TypeName type = TypeName.get(element.asType()); String name = element.getSimpleName().toString(); return ParameterSpec.builder(type, name) .addModifiers(element.getModifiers()) .build(); }
private void processMethod(Element element, T holder) { ExecutableElement executableElement = (ExecutableElement) element; VariableElement param = executableElement.getParameters().get(0); String methodName = executableElement.getSimpleName().toString(); JBlock block = createBlock(holder, true); AbstractJClass type = codeModelHelper.typeMirrorToJClass(param.asType()); JVar fieldRef = block.decl(type, param.getSimpleName().toString(), getDefault(param.asType())); handler.assignValue(block, fieldRef, holder, element, param); block.add(JExpr.invoke(methodName).arg(fieldRef)); }
private CharSequence appendParameters( ExecutableElement m, StringBuilder signature, DeclaringType declaringType, boolean withTypes, boolean allFinal) { signature.append("("); boolean notFirst = false; for (VariableElement p : m.getParameters()) { if (notFirst) { signature.append(", "); } if (allFinal) { signature.append("final "); } if (withTypes) { signature.append(printType(p, p.asType(), declaringType)); signature.append(" "); } signature.append(p.getSimpleName()); notFirst = true; } return signature.append(")"); }
protected static List<ParameterSpec> buildParamSpecs(List<? extends VariableElement> params) { List<ParameterSpec> result = new ArrayList<>(); for (VariableElement param : params) { Builder builder = ParameterSpec.builder(TypeName.get(param.asType()), param.getSimpleName().toString()); for (AnnotationMirror annotation : param.getAnnotationMirrors()) { builder.addAnnotation(AnnotationSpec.get(annotation)); } result.add(builder.build()); } return result; }
private void writeConstantField(JavaFileWriter writer, DeclaredTypeName containingClassName, VariableElement constant) throws IOException { JavadocPlugin.writeJavadocFromElement(pluginEnv, writer, constant); writer.writeFieldDeclaration( utils.getTypeNameFromTypeMirror(constant.asType()), constant.getSimpleName().toString(), Expressions.staticReference(containingClassName, constant.getSimpleName().toString()), TypeConstants.PUBLIC_STATIC_FINAL); } }
private void collectTypedefs(TypeElement type, Map<String, TypeMirror> collected) { for (VariableElement field : ElementFilter.fieldsIn(elements.getAllMembers(type))) { if (field.getAnnotation(Generator.Typedef.class) != null) { collected.put(field.getSimpleName().toString(), field.asType()); } } }
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 IJExpression getExtraValue(VariableElement parameter, JVar extras, JBlock block, JMethod annotatedMethod, JDefinedClass generatedClass) { String parameterName = parameter.getSimpleName().toString(); AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType()); String extraKey = getAnnotationValue(parameter); if (extraKey == null || extraKey.isEmpty()) { extraKey = parameterName; } BundleHelper bundleHelper = new BundleHelper(getEnvironment(), parameter.asType()); IJExpression restoreMethodCall = bundleHelper.getExpressionToRestoreFromBundle(parameterClass, extras, getStaticExtraField(generatedClass, extraKey), annotatedMethod); return block.decl(parameterClass, parameterName, restoreMethodCall); }
/** * Verify the annotated method. */ private void validateMethod(ExecutableElement methodElement) { if (methodElement.getModifiers().contains(Modifier.ABSTRACT)) { // no abstract throw new RuntimeException(String.format("The method(%s) annotated by @Route is abstract.", methodElement.getSimpleName())); } List<? extends VariableElement> parameters = methodElement.getParameters(); if (!parameters.isEmpty()) { // params must be annotated by @InjectParam for (VariableElement variableElement : parameters) { // param's type must be String if (!variableElement.asType().toString().equals("java.lang.String")) { throw new RuntimeException(String.format("The method's(%s) parameters must be String.", methodElement.getSimpleName())); } InjectParam injectParam = variableElement.getAnnotation(InjectParam.class); if (injectParam == null) { throw new RuntimeException(String.format("The method's(%s) parameters must be annotated by @InjectParam.", methodElement.getSimpleName())); } if ("".equals(injectParam.key().trim())) { throw new RuntimeException(String.format("The parameter(%s) annotated by @InjectParam must has a non-empty key.", variableElement.getSimpleName())); } } } }
VariableElement param = parameters.get(paramIndex); if (param.equals(element)) { AbstractJClass type = codeModelHelper.typeMirrorToJClass(param.asType()); JVar fieldRef = targetBlock.decl(type, param.getSimpleName().toString(), getDefault(param.asType()));