@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(); }
private void generateHelperClassForController(ControllerClassInfo controllerInfo) throws IOException { ParameterizedTypeName parameterizeSuperClass = ParameterizedTypeName .get(ClassNames.EPOXY_CONTROLLER_HELPER, controllerInfo.getControllerClassType()); TypeSpec.Builder builder = TypeSpec.classBuilder(controllerInfo.getGeneratedClassName()) .addJavadoc("Generated file. Do not modify!") .addModifiers(Modifier.PUBLIC) .superclass(parameterizeSuperClass) .addField(controllerInfo.getControllerClassType(), "controller", Modifier.FINAL, Modifier.PRIVATE) .addMethod(buildConstructor(controllerInfo)) .addMethod(buildResetModelsMethod(controllerInfo)); if (configManager.shouldValidateModelUsage()) { builder.addFields(buildFieldsToSaveModelsForValidation(controllerInfo)) .addMethod(buildValidateModelsHaveNotChangedMethod(controllerInfo)) .addMethod(buildValidateSameValueMethod()) .addMethod(buildSaveModelsForNextValidationMethod(controllerInfo)); } JavaFile.builder(controllerInfo.getGeneratedClassName().packageName(), builder.build()) .build() .writeTo(filer); }
void generateJavaFiles( String contractName, String bin, List<AbiDefinition> abi, String destinationDir, String basePackageName, Map<String, String> addresses) throws IOException, ClassNotFoundException { String className = Strings.capitaliseFirstLetter(contractName); TypeSpec.Builder classBuilder = createClassBuilder(className, bin); classBuilder.addMethod(buildConstructor(Credentials.class, CREDENTIALS, false)); classBuilder.addMethod(buildConstructor(Credentials.class, CREDENTIALS, true)); classBuilder.addMethod(buildConstructor(TransactionManager.class, TRANSACTION_MANAGER, false)); classBuilder.addMethod(buildConstructor(TransactionManager.class, TRANSACTION_MANAGER, true)); classBuilder.addFields(buildFuncNameConstants(abi)); classBuilder.addMethods( buildFunctionDefinitions(className, classBuilder, abi)); classBuilder.addMethod(buildLoad(className, Credentials.class, CREDENTIALS, false)); classBuilder.addMethod(buildLoad(className, TransactionManager.class, TRANSACTION_MANAGER, false)); classBuilder.addMethod(buildLoad(className, Credentials.class, CREDENTIALS, true)); classBuilder.addMethod(buildLoad(className, TransactionManager.class, TRANSACTION_MANAGER, true)); if (!bin.equals(Contract.BIN_NOT_PROVIDED)) { classBuilder.addMethods(buildDeployMethods(className, classBuilder, abi)); } addAddressesSupport(classBuilder, addresses); write(basePackageName, classBuilder.build(), destinationDir); }
public void writer(Filer filer) throws IOException { TypeSpec.Builder outClassBuilder = TypeSpec.classBuilder(model.getClassName().simpleName()); outClassBuilder.addModifiers(Modifier.PUBLIC); HashMap<String, String> experimentsHashMap = model.getExperimentsHashMap(); outClassBuilder .addFields(createField(experimentsHashMap)) .addMethod(createGetParams(experimentsHashMap)) .addMethod(createGetList(experimentsHashMap)); TypeSpec outClass = outClassBuilder.build(); JavaFile.builder(model.getClassName().packageName(), outClass) .build() .writeTo(filer); }
private TypeSpec createTypeSpec() { return TypeSpec.classBuilder(storeModel.getClassName().simpleName()) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addSuperinterface(storeModel.getInterfaceName()) .superclass(TypeName.get(BaseObservable.class)) .addFields(createFieldSpecs()) .addMethod(createConstructor()) .addMethod(createBuilderMethodSpec()) .addMethods(createGetterMethodSpecs()) .addMethod(createDispatchMethodSpec()) .addType(new StoreBuilderClassGenerator(storeModel).createBuilderTypeSpec()) .build(); }
@Override public TypeSpec poetSpec() { return TypeSpec.classBuilder(className) .addJavadoc("{@link $T} Marshaller", requestClassName) .addModifiers(Modifier.PUBLIC) .addAnnotation(PoetUtils.generatedAnnotation()) .addAnnotation(SdkInternalApi.class) .addSuperinterface(ParameterizedTypeName.get(baseMashallerName, requestName)) .addFields(protocolSpec.memberVariables()) .addFields(protocolSpec.additionalFields()) .addMethods(methods()) .build(); }
void write(Filer filer) throws IOException { TypeSpec clazz = TypeSpec.classBuilder(TARGET_CLASS_NAME) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addSuperinterface(CLASS_DISPATCHER) .addFields(createSubDispatcherField(subDispatcherHolderMap)) .addMethod(createBindWithArgsMethod(bindingClasses, subDispatcherHolderMap)) .addMethod(createBindFragmentMethod(bindingClasses, subDispatcherHolderMap)) .addMethod(createPackMethod(bindingClasses, subDispatcherHolderMap)) .build(); JavaFile.builder(packageName, clazz) .build() .writeTo(filer); }
private TypeSpec generateTypeSpec(TypeModel model) { TypeSpec.Builder builder = TypeSpec .classBuilder(model.name) .addFields(generateFieldSpecs(model)) .addMethods(generateMethodSpecs(model)) .addModifiers(Modifier.PUBLIC, Modifier.FINAL); if (model.superclass != null) { builder.superclass(model.superclass); } if (model.superinterface != null) { builder.addSuperinterface(model.superinterface); } return builder.build(); }
@Override public TypeSpec poetSpec() { return TypeSpec.classBuilder(className) .addJavadoc("{@link $T} Marshaller", requestClassName) .addModifiers(Modifier.PUBLIC) .addAnnotation(PoetUtils.generatedAnnotation()) .addAnnotation(SdkInternalApi.class) .addSuperinterface(ParameterizedTypeName.get(baseMashallerName, requestName)) .addFields(protocolSpec.memberVariables()) .addFields(protocolSpec.additionalFields()) .addMethods(methods()) .build(); }
public TypeSpec createBuilderTypeSpec() { return TypeSpec.classBuilder(builderModel.getClassName().simpleName()) .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .addFields(createFieldSpecs()) .addMethod(createAddMiddlewareMethodSpec()) .addMethod(createBuilderConstructor()) .addMethods(createReducerSetterMethodSpecs()) .addMethods(createReducerAndStateSetterMethodSpecs()) .addMethod(createBuildMethodSpec()) .build(); }
public static String createTestSource(String className, Iterable<FieldSpec> fieldSpecs) { TypeSpec testType = TypeSpec.classBuilder(className) .addModifiers(Modifier.PUBLIC, Modifier.FINAL).addFields(fieldSpecs).build(); JavaFile javaFile = JavaFile.builder(IntegrationTestBase.TEST_PACKAGE, testType).build(); // javaFile.toString() does the same thing as using a string writer // internally return javaFile.toString(); }
public final TypeSpec type() { return TypeSpec.classBuilder(naming.levelClassName()) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addTypeVariables(typeVariables()) .superclass(naming.levelSuperclassTypeName()) .addFields(fields()) .addMethod(constructor()) .addMethods(allowedChildMethods()) .addMethod(endTag()) .addMethod(self()) .build(); }
private TypeSpec createViewHolderClass(ViewHolderInfo viewHolderInfo) { return TypeSpec .classBuilder(viewHolderInfo.name) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addFields(createViewHolderFields(viewHolderInfo.viewInfos)) .superclass(sViewHolderSuperClassName) .addMethod(createConstructorForViewHolder(viewHolderInfo.viewInfos)) .build(); }
private Builder specBuilder() { Builder builder = TypeSpec.classBuilder(className).addModifiers(modifiers).addFields(specs) .addTypes(innerClasses.stream().map(s -> s.specBuilder().build()) .collect(Collectors.toList())); if (superClass != null) builder.superclass(ClassName.get(superClass.packageName, superClass.className)); for (BiFunction<Builder, TestSource, Builder> function : builderTransformers) { builder = function.apply(builder, this); } return builder; }
private TypeSpec type() { EXE_SET.stream() .map(exe -> exe.get(pojoInfo)) .forEach(exe -> exe.acceptCompanionType(this)); return TypeSpec.classBuilder(className.simpleName()) .addAnnotation(GENERATED) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addFields(fieldSpecList) .addMethods(methodSpecList) .build(); }
public TypeSpec build(RepoType repoType) { return TypeSpec.classBuilder(repoType.simpleName()) .addAnnotation(GENERATED) .addModifiers(Modifier.FINAL) .superclass(repoType.superTypeName()) .addFields(injectSet.stream() .map(OrmInject::fieldSpec) .collect(Collectors.toList())) .addMethod(constructor()) .addMethods(methodList) .build(); }
private static TypeSpec createTypeSpec(RuntimePermissionsElement element, TypeResolver typeResolver) { return TypeSpec.classBuilder(element.getGeneratedClassName()) .addModifiers(Modifier.FINAL) .addFields(createFields(element.getNeedsPermissionsMethods())) .addMethod(createConstructor()) .addMethods(createWithCheckMethods(element)) .addMethods(createPermissionHandlingMethods(element)) .addTypes(createPermissionRequestClasses(element)) .build(); }
@Override public TypeSpec buildTypeSpec() { TypeSpec.Builder classBuilder = TypeSpec.classBuilder(schema.getSchemaClassName()); if (schema.isGeneric()) { classBuilder.addAnnotation(Annotations.suppressWarnings("rawtypes")); } classBuilder.addModifiers(Modifier.PUBLIC); classBuilder.addSuperinterface(Types.getSchema(schema.getModelClassName())); classBuilder.addFields(buildFieldSpecs()); classBuilder.addMethods(buildMethodSpecs()); return classBuilder.build(); }
@Test public void testBuildFuncNameConstants() throws Exception { AbiDefinition functionDefinition = new AbiDefinition( false, Arrays.asList( new AbiDefinition.NamedType("param", "uint8")), "functionName", Collections.emptyList(), "function", true); TypeSpec.Builder builder = TypeSpec.classBuilder("testClass"); builder.addFields(solidityFunctionWrapper .buildFuncNameConstants(Collections.singletonList(functionDefinition))); //CHECKSTYLE:OFF String expected = "class testClass {\n" + " public static final java.lang.String FUNC_FUNCTIONNAME = \"functionName\";\n" + "}\n"; //CHECKSTYLE:ON assertThat(builder.build().toString(), is(expected)); }
public void addToTypeSpec(TypeSpec.Builder typeSpec) { for (JavadocSpec javadocSpec : javadocSpecs) { typeSpec.addJavadoc(javadocSpec.format, javadocSpec.args); } typeSpec.addAnnotations(annotationSpecs); typeSpec.addFields(fieldSpecs); typeSpec.addMethods(methodSpecs); typeSpec.addTypes(typeSpecs); typeSpec.addSuperinterfaces(superInterfaces); }