public static MethodSpec.Builder overriding(ExecutableElement method) { return MethodSpec.methodBuilder(method.getSimpleName().toString()) .addAnnotation(Override.class) .addModifiers(method.getModifiers().stream().filter(modifier -> modifier != Modifier.ABSTRACT).collect(Collectors.toList())) .returns(TypeName.get(method.getReturnType())) .varargs(method.isVarArgs()) .addExceptions(method.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .addTypeVariables(method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList())) .addParameters(method.getParameters().stream().map(element -> ParameterSpec.get(element).toBuilder() .addAnnotations(element.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(Collectors.toList())).build()).collect(Collectors.toList())); }
methodBuilder.addParameters(ParameterSpec.parametersOf(method)); methodBuilder.varargs(method.isVarArgs());
.addParameters(FluentIterable.from(loaderClasses).transform( new Function<TypeElement, ParameterSpec>() { @Override public ParameterSpec apply(TypeElement typeElement) {
private MethodSpec findByPrimaryKey1() { ClassName optionalClassName = ClassName.get(Optional.class); return MethodSpec.methodBuilder("maybe") .addModifiers(Modifier.PUBLIC) .addParameters(primaryKeyParameterSpecList) .returns(ParameterizedTypeName.get(optionalClassName, naming.superClassTypeName())) .addCode(QueryMethodBody.builder(pojoInfo, QueryReturnType.OPTIONAL) .whereExpression(new Where()) .build()) .build(); }
public MethodSpec write() { Builder b = MethodSpec.methodBuilder(methodInfo.name()) .addAnnotation(Override.class) .addModifiers(modifiers()) .addParameters(parameters()) .returns(returnType()); for (CodeBlock codeBlock : statementList) { b.addCode(codeBlock); } return b.build(); }
private MethodSpec generateConstructor(ImmutableList<Property> properties) { List<ParameterSpec> params = Lists.newArrayListWithCapacity(properties.size()); for (Property property : properties) { params.add(ParameterSpec.builder(property.typeName, property.fieldName).build()); } MethodSpec.Builder builder = MethodSpec.constructorBuilder() .addParameters(params); for (ParameterSpec param : params) { builder.addStatement("this.$N = $N", param.name, param.name); } return builder.build(); }
@Override public MethodSpec apply(StoreMethodModel input) { return MethodSpec.methodBuilder(input.getName()) .addAnnotation(getOverrideAnnotation()) .addModifiers(Modifier.PUBLIC) .returns(TypeName.get(input.getReturnType())) .addParameters(input.getParameters()) .addCode(input.getCodeBlock()) .build(); } })
private MethodSpec m1(List<ParameterSpec> parameterList, TypeName returnTypeName, RelationalTypeName rtName) { return MethodSpec.methodBuilder(propertyName()) .addModifiers(Modifier.ABSTRACT) .returns(returnTypeName) .addParameters(parameterList) .addParameter(rtName.typeName(), "key") .build(); }
private MethodSpec m0(List<ParameterSpec> parameterList, TypeName returnTypeName, RelationalTypeName rtName) { return MethodSpec.methodBuilder(propertyName()) .addParameters(parameterList) .returns(returnTypeName) .addStatement("return $L(rs, columnName, rs.$L(columnName))", propertyName(), rtName.resultSetMethod()) .build(); }
public MethodSpec get() { return MethodSpec.constructorBuilder() .addModifiers(Modifier.PRIVATE) .addParameters(parameterSpecList()) .addCode(body()) .build(); }
private MethodSpec findByPrimaryKey0() { String paramNames = primaryKeyParameterSpecList.stream() .map(param -> param.name) .collect(Collectors.joining(", ")); return MethodSpec.methodBuilder("find") .addModifiers(Modifier.PUBLIC) .addParameters(primaryKeyParameterSpecList) .returns(naming.superClassTypeName()) .addStatement("return maybe($L).orElseThrow($T::new)", paramNames, NoResultFoundException.class) .build(); }
private MethodSpec builderClassSetter() { MethodSpec.Builder method = MethodSpec.methodBuilder(name) .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .returns(naming().builderInnerTypeName(methodInfo())) .addParameters(parameterSpecList) .varargs(varargs) .addCode(body .addStatement("return this") .build()); return methodBuild(method); }
@Nonnull public MethodSpec generate() { return MethodSpec.methodBuilder(methodName) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .returns(specType) .addParameters(generateParameters()) .addCode(generateCodeBefore()) .addCode(generateReturnCodeBlock()) .build(); }
private MethodSpec builderClassSetter() { MethodSpec.Builder method = MethodSpec.methodBuilder(name) .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .returns(naming().builderInnerTypeName(methodInfo())) .addParameters(parameterSpecList) .varargs(varargs) .addCode(body .addStatement("return this") .build()); return methodBuild(method); }
private static MethodSpec newConstructor(Map<String, ExecutableElement> properties) { List<ParameterSpec> params = Lists.newArrayList(); for (Map.Entry<String, ExecutableElement> entry : properties.entrySet()) { TypeName typeName = TypeName.get(entry.getValue().getReturnType()); params.add(ParameterSpec.builder(typeName, entry.getKey()).build()); } CodeBlock code = addProperties(CodeBlock.builder().add("super"), properties.keySet().toArray()); return MethodSpec.constructorBuilder().addParameters(params).addCode(code).build(); }
private MethodSpec builderIfaceMethod() { MethodSpec.Builder method = MethodSpec.methodBuilder(name) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT) .returns(naming().builderInnerTypeName(methodInfo())) .addParameters(parameterSpecList) .varargs(varargs); return methodBuild(method); }
.constructorBuilder() .addModifiers(constructor.getModifiers()) .addParameters(ProcessorUtils.extractParameters(constructor)) .addStatement("super($L)", constructor.getParameters());
String addParameters( MethodSpec.Builder methodBuilder, List<AbiDefinition.NamedType> namedTypes) { List<ParameterSpec> inputParameterTypes = buildParameterTypes(namedTypes); List<ParameterSpec> nativeInputParameterTypes = new ArrayList<>(inputParameterTypes.size()); for (ParameterSpec parameterSpec : inputParameterTypes) { TypeName typeName = getWrapperType(parameterSpec.type); nativeInputParameterTypes.add( ParameterSpec.builder(typeName, parameterSpec.name).build()); } methodBuilder.addParameters(nativeInputParameterTypes); if (useNativeJavaTypes) { return Collection.join( inputParameterTypes, ", \n", // this results in fully qualified names being generated this::createMappedParameterTypes); } else { return Collection.join( inputParameterTypes, ", ", parameterSpec -> parameterSpec.name); } }
.addCode(diConstructor.code) .addModifiers(diConstructor.modifiers) .addParameters(diConstructor.parameters); } else { constructorBuilder.addModifiers(Modifier.PRIVATE);
private MethodSpec.Builder baseMethod(@NonNull ClassName builderName) { final MethodSpec.Builder method = MethodSpec.methodBuilder(getName()) .addModifiers(modifiers) .addParameters(parameters) .addTypeVariables(typeVariables) .addAnnotations(getAnnotations()); if (javadoc != null) { method.addJavadoc(javadoc.replaceAll("(\n|^) ", "$1")); } if (getType().equals(TypeName.VOID)) { method.returns(builderName) .addAnnotation(Types.NON_NULL) .addJavadoc("@return this instance\n"); } else { method.returns(getType()); } return method; }