private static MethodSpec.Builder getMethodSpecBuilder( SpecModel specModel, final List<ParameterSpec> parameters, final CodeBlock codeBlock, final String name) { final MethodSpec.Builder builder = MethodSpec.methodBuilder(name) .addModifiers(Modifier.PUBLIC) .returns(getMatcherType(specModel)) .addCode(codeBlock); for (final ParameterSpec param : parameters) { builder.addParameter(param); } builder.addStatement("return this"); return builder; }
private static <T extends SpecModel & HasEnclosedSpecModel> MethodSpec generateBuildMethod( final T specModel) { final MethodSpec.Builder buildMethodBuilder = MethodSpec.methodBuilder("build") .addModifiers(Modifier.PUBLIC) .returns(getMatcherConditionTypeName()); final CodeBlock innerMatcherLogicBlock = generateMatchMethodBody(specModel); final TypeSpec matcherInnerClass = TypeSpec.anonymousClassBuilder("") .superclass(getMatcherConditionTypeName()) .addMethod( MethodSpec.methodBuilder("matches") .addModifiers(Modifier.PUBLIC) .addParameter(ClassNames.INSPECTABLE_COMPONENT, "value") .returns(TypeName.BOOLEAN) .addAnnotation(Override.class) .addCode(innerMatcherLogicBlock) .build()) .build(); return buildMethodBuilder .addStatement("final $T mainBuilder = $L", getMatcherConditionTypeName(), matcherInnerClass) .addStatement( "return $T.allOf(mainBuilder, $T.buildCommonMatcher(this))", ClassNames.ASSERTJ_JAVA6ASSERTIONS, ClassNames.BASE_MATCHER_BUILDER) .build(); }
private MethodSpec getMethod(ExecutableElement constructor, boolean disambiguateFields, boolean injectMembers, ClassName injectedClassName) { MethodSpec.Builder result = MethodSpec.methodBuilder("get") .addJavadoc(AdapterJavadocs.GET_METHOD, injectedClassName) .addAnnotation(Override.class) .returns(injectedClassName) .addModifiers(PUBLIC); result.addCode("$T result = new $T(", injectedClassName, injectedClassName); boolean first = true; for (VariableElement parameter : constructor.getParameters()) { if (!first) result.addCode(", "); else first = false; result.addCode("$N.get()", parameterName(disambiguateFields, parameter)); } result.addCode(");\n"); if (injectMembers) { result.addStatement("injectMembers(result)"); } result.addStatement("return result"); return result.build(); }
methodSpecBuilder.addCode(constructor.build()); typeSpecDataHolder.addMethod(methodSpecBuilder.build());
.addModifiers(Modifier.PROTECTED) .addParameter(ClassNames.RENDER_DATA, "previousRenderData") .addCode(code) .build();
builder.add("$L;\n", method.defaultReturn()); callbackMethod.addCode(builder.build()); callback.addMethod(callbackMethod.build());
private MethodSpec messageAdapterEncode(NameAllocator nameAllocator, MessageType type, TypeName javaType, boolean useBuilder) { MethodSpec.Builder result = MethodSpec.methodBuilder("encode") .addAnnotation(Override.class) .addModifiers(PUBLIC) .addParameter(ProtoWriter.class, "writer") .addParameter(javaType, "value") .addException(IOException.class); for (Field field : type.fieldsAndOneOfFields()) { int fieldTag = field.tag(); CodeBlock adapter = adapterFor(field); result.addCode("$L.encodeWithTag(writer, $L, ", adapter, fieldTag) .addCode((useBuilder ? "value.$L" : "$L(value)"), nameAllocator.get(field)) .addCode(");\n"); } if (useBuilder) { result.addStatement("writer.writeBytes(value.unknownFields())"); } return result.build(); }
private MethodSpec createShortcuts() { final MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("createShortcuts") .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .returns(listOfListOfShortcutInfo) .addParameter(context, "context") .addStatement("$T<$T> enabledShortcuts = new $T<>()", List.class, shortcutInfo, ArrayList.class) .addStatement("$T<$T> disabledShortcuts = new $T<>()", List.class, shortcutInfo, ArrayList.class); for (final ShortcutAnnotatedElement annotatedElement : annotatedElements) { Shortcut shortcut = annotatedElement.getShortcut(); methodBuilder.addCode("$L.add(", shortcut.enabled() ? "enabledShortcuts" : "disabledShortcuts"); methodBuilder.addCode(createShortcut(annotatedElement)); methodBuilder.addStatement(")"); } return methodBuilder .addStatement("return $T.asList(enabledShortcuts, disabledShortcuts)", Arrays.class) .build(); }
private void emitFieldBindings(MethodSpec.Builder builder, ExtraInjection binding) { Collection<FieldBinding> fieldBindings = binding.getFieldBindings(); if (fieldBindings.isEmpty()) { return; } for (FieldBinding fieldBinding : fieldBindings) { builder.addCode("target.$L = ", fieldBinding.getName()); if (fieldBinding.isParcel()) { builder.addCode("org.parceler.Parcels.unwrap((android.os.Parcelable) object);\n"); } else { emitCast(builder, fieldBinding.getType()); builder.addCode("object;\n"); } } }
.addCode(diConstructor.code) .addModifiers(diConstructor.modifiers) .addParameters(diConstructor.parameters);
private void emitCast(MethodSpec.Builder builder, TypeMirror fieldType) { builder.addCode("($T) ", TypeName.get(fieldType)); }
static TypeSpecDataHolder generateGetEventHandlerMethod( SpecModel specModel, EventDeclarationModel eventDeclaration) { final String scopeMethodName = specModel.getScopeMethodName(); return TypeSpecDataHolder.newBuilder() .addMethod( MethodSpec.methodBuilder("get" + eventDeclaration.name.simpleName() + "Handler") .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .returns(ClassNames.EVENT_HANDLER) .addParameter(specModel.getContextClass(), "context") .addCode( CodeBlock.builder() .beginControlFlow("if (context.$L() == null)", scopeMethodName) .addStatement("return null") .endControlFlow() .build()) .addStatement( "return (($L) context.$L()).$L", specModel.getComponentName(), scopeMethodName, ComponentBodyGenerator.getEventHandlerInstanceName(eventDeclaration.name)) .build()) .build(); }
private MethodSpec messageFieldsConstructor(NameAllocator nameAllocator, MessageType type) { MethodSpec.Builder result = MethodSpec.constructorBuilder(); result.addModifiers(PUBLIC); result.addCode("this("); for (Field field : type.fieldsAndOneOfFields()) { TypeName javaType = fieldType(field); String fieldName = nameAllocator.get(field); ParameterSpec.Builder param = ParameterSpec.builder(javaType, fieldName); if (emitAndroidAnnotations && field.isOptional()) { param.addAnnotation(NULLABLE); } result.addParameter(param.build()); result.addCode("$L, ", fieldName); } result.addCode("$T.EMPTY);\n", BYTE_STRING); return result.build(); }
@Override public void exitRule(Rule rule) { // create fields for each used function classFile.addFields(functionMembers); // create fields for hoisted constant expressions classFile.addFields(hoistedExpressionMembers); // TODO these can be shared and should potentially created by an AnnotationProcessor for each defined function instead of every rule classFile.addTypes(functionArgsHolderTypes); // resolve functions (but only do so once for each function) constructorBuilder.addStatement("// resolve used functions"); functionReferences.forEach(block -> constructorBuilder.addStatement("$L", block)); // add initializers for fields that depend on the functions being set constructorBuilder.addStatement("// function parameters"); constructorBuilder.addCode(lateConstructorBlock.build()); // all the expressions/statements that are constant at compile time constructorBuilder.addStatement("// constant expressions"); constructorBuilder.addCode(hoistedConstantExpressions.build()); classFile.addMethod(constructorBuilder.build()); generatedFile = JavaFile.builder("org.graylog.plugins.pipelineprocessor.$dynamic.rules", classFile.build()) .build(); }
/** Generate a delegate to the Spec that defines this onTrigger method. */ private static MethodSpec generateWorkingRangeMethodDelegate( SpecModel specModel, SpecMethodModel<EventMethod, WorkingRangeDeclarationModel> methodModel) { final MethodSpec.Builder methodSpec = MethodSpec.methodBuilder(methodModel.name.toString()) .addModifiers(Modifier.PRIVATE) .returns(TypeName.VOID) .addParameter(ClassNames.COMPONENT_CONTEXT, "c"); final CodeBlock.Builder delegation = CodeBlock.builder(); final String sourceDelegateAccessor = SpecModelUtils.getSpecAccessor(specModel); delegation.add("$L.$L(\n", sourceDelegateAccessor, methodModel.name); delegation.indent(); for (int i = 0, size = methodModel.methodParams.size(); i < size; i++) { final MethodParamModel methodParamModel = methodModel.methodParams.get(i); delegation.add( "($T) $L", methodParamModel.getTypeName(), getImplAccessor(specModel, methodParamModel)); delegation.add((i < methodModel.methodParams.size() - 1) ? ",\n" : ");\n"); } delegation.unindent(); methodSpec.addCode(delegation.build()); return methodSpec.build(); }
private static MethodSpec generateRecordRenderDataMethod(SpecModel specModel) { final TypeName renderInfoTypeName = ClassName.bestGuess(getRenderDataImplClassName(specModel)); final CodeBlock code = CodeBlock.builder() .add("$T $L = $L != null ?\n", renderInfoTypeName, "renderInfo", "toRecycle") .indent() .add("($T) $L :\n", renderInfoTypeName, "toRecycle") .add("new $T();\n", renderInfoTypeName) .unindent() .addStatement("$L.record(this)", "renderInfo") .addStatement("return $L", "renderInfo") .build(); return MethodSpec.methodBuilder("recordRenderData") .addAnnotation(Override.class) .addModifiers(Modifier.PROTECTED) .addParameter(ClassNames.RENDER_DATA, "toRecycle") .returns(ClassNames.RENDER_DATA) .addCode(code) .build(); }
@NonNull MethodSpec build() { if (anyNonDefault.size() > 0) { methodBuilder.beginControlFlow("if ($L)", anyNonDefault.entrySet().stream().map(field -> CodeBlock.builder().add(field.getKey()).add(" == ").add(field.getValue()).build()) .reduce((c1, c2) -> CodeBlock.builder().add(c1).add(" && ").add(c2).build()).orElseGet(() -> CodeBlock.of("true"))) .addStatement("throw new $T(\"One of $L must not be default\")", ACRAConfigurationException.class, anyNonDefault.keySet().stream().collect(Collectors.joining(", "))) .endControlFlow(); } methodBuilder.endControlFlow(); for (CodeBlock s : statements) { methodBuilder.addCode(s); } methodBuilder.addStatement("return new $T(this)", config); return methodBuilder.build(); }
"Bindings already cleared."); result.addStatement("$N = null", hasFieldBindings() ? "this.target" : "target"); result.addCode("\n"); for (ViewBinding binding : viewBindings) { if (binding.getFieldBinding() != null) { result.addCode("\n"); for (ViewBinding binding : viewBindings) { addFieldAndUnbindStatement(bindingClass, result, binding); result.addCode("\n"); result.addStatement("super.unbind()");