void write(String packageName, TypeSpec typeSpec, String destinationDir) throws IOException { JavaFile javaFile = JavaFile.builder(packageName, typeSpec) .indent(" ") .skipJavaLangImports(true) .build(); javaFile.writeTo(new File(destinationDir)); }
public String getJavaClassFile() { try { return JavaFile.builder(mJsonObjectHolder.packageName, getTypeSpec()).build().toString(); } catch (Exception e) { e.printStackTrace(); return null; } }
private void writeAsyncClass(Element elem) throws ClassNotFoundException, IOException, Exception { if (elem.getKind().isInterface()) { TypeElement interfaceClazz = (TypeElement) elem; String className = interfaceClazz.getSimpleName().toString(); TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder(className + ASYNC).addModifiers(Modifier.PUBLIC) .addSuperinterface(TypeName.get(elem.asType())); // add class generic type classBuilder.addTypeVariables(getTypeNames(interfaceClazz.getTypeParameters())); // add direct method addMethods(interfaceClazz, classBuilder); // add method form superinterface addSuperInterfaceMethods(interfaceClazz.getInterfaces(), classBuilder); // write class JavaFile javaFile = JavaFile.builder(processingEnv.getElementUtils().getPackageOf(interfaceClazz).getQualifiedName().toString(), classBuilder.build()).build(); javaFile.writeTo(new File(System.getProperty("basedir"), TARGET_DIR)); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "MotanAsyncProcessor not process, because " + elem.toString() + " not a interface."); } }
private void generate(Set<String> viewClassSet) throws IllegalAccessException, IOException { mMessager.printMessage(Diagnostic.Kind.NOTE, "生成 " + viewClassSet.size() + " 个"); for (String clazz : viewClassSet) { int lastDotIndex = clazz.lastIndexOf("."); String superPackageName = clazz.substring(0, lastDotIndex); String superClassName = clazz.substring(lastDotIndex + 1); String className = CLASS_PREFIX + superClassName; mMessager.printMessage(Diagnostic.Kind.NOTE, clazz + " ====> " + className); TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(className) .addJavadoc(CLASS_JAVA_DOC) .addModifiers(Modifier.PUBLIC) .superclass(ClassName.get(superPackageName, superClassName)) .addSuperinterface(ClassName.get(PACKAGE_NAME, "BGABadgeable")) .addField(ClassName.get(PACKAGE_NAME, "BGABadgeViewHelper"), "mBadgeViewHelper", Modifier.PRIVATE); generateMethod(typeBuilder, clazz); JavaFile javaFile = JavaFile.builder(PACKAGE_NAME, typeBuilder.build()).build(); javaFile.writeTo(mFileUtils); } }
@Test public void map() throws Exception { Schema schema = new RepoBuilder() .add("message.proto", "" + "message Message {\n" + " map<string, CdnResource> templates = 1;\n" + " message CdnResource {\n" + " }\n" + "}\n") .schema(); MessageType message = (MessageType) schema.getType("Message"); JavaGenerator javaGenerator = JavaGenerator.get(schema); TypeSpec typeSpec = javaGenerator.generateType(message); assertThat(JavaFile.builder("", typeSpec).build().toString()).contains("" + " @WireField(\n" + " tag = 1,\n" + " keyAdapter = \"com.squareup.wire.ProtoAdapter#STRING\",\n" + " adapter = \"Message$CdnResource#ADAPTER\"\n" + " )\n" + " public final Map<String, CdnResource> templates;\n"); }
/** * Writes the given class to a respective file in the configuration package * * @param filer filer to write to * @param typeSpec the class * @throws IOException if writing fails */ public static void writeClass(@NonNull Filer filer, @NonNull TypeSpec typeSpec) throws IOException { JavaFile.builder(PACKAGE, typeSpec) .skipJavaLangImports(true) .indent(" ") .addFileComment("Copyright (c) " + Calendar.getInstance().get(Calendar.YEAR) + "\n\n" + "Licensed under the Apache License, Version 2.0 (the \"License\");\n" + "you may not use this file except in compliance with the License.\n\n" + "http://www.apache.org/licenses/LICENSE-2.0\n\n" + "Unless required by applicable law or agreed to in writing, software\n" + "distributed under the License is distributed on an \"AS IS\" BASIS,\n" + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" + "See the License for the specific language governing permissions and\n" + "limitations under the License.") .build() .writeTo(filer); } }
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); }
@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 writeJavaFile(ClassName javaTypeName, TypeSpec typeSpec, Location location, Stopwatch stopwatch) throws IOException { JavaFile.Builder builder = JavaFile.builder(javaTypeName.packageName(), typeSpec) .addFileComment("Code generated by $L, do not edit.", CodegenSample.class.getName()); if (location != null) { builder.addFileComment("\nSource file: $L", location.path()); } JavaFile javaFile = builder.build(); try { javaFile.writeTo(new File(generatedSourceDirectory)); } catch (IOException e) { throw new IOException("Failed to write " + javaFile.packageName + "." + javaFile.typeSpec.name + " to " + generatedSourceDirectory, e); } log.info("Generated %s in %s", javaTypeName, stopwatch); }
private void writeJavaFile(ClassName javaTypeName, TypeSpec typeSpec, Location location) throws IOException { JavaFile.Builder builder = JavaFile.builder(javaTypeName.packageName(), typeSpec) .addFileComment("$L", "Code generated by Wire protocol buffer compiler, do not edit."); if (location != null) { builder.addFileComment("\nSource file: $L", location); } JavaFile javaFile = builder.build(); try { javaFile.writeTo(new File(generatedSourceDirectory)); } catch (IOException e) { throw new IOException("Failed to write " + javaFile.packageName + "." + javaFile.typeSpec.name + " to " + generatedSourceDirectory, e); } } }
@Override public boolean compile(RoundEnvironment roundEnv) { try { JavaFile.builder(getRClassBuilder().getClassName().packageName(), getRClassBuilder().build()) .build() .writeTo(getFiler()); } catch (IOException e) { // Allowing to successive rewrite file return true; } return true; }
@Override public String brewJava() { TypeSpec.Builder binderTypeSpec = TypeSpec.classBuilder(binderClassName()).addModifiers(Modifier.PUBLIC); emitBind(binderTypeSpec); JavaFile javaFile = JavaFile.builder(target.classPackage, binderTypeSpec.build()) .addFileComment("Generated code from Dart. Do not modify!") .build(); return javaFile.toString(); }
@Override public String brewJava() { TypeSpec.Builder binderTypeSpec = TypeSpec.classBuilder(binderClassName()).addModifiers(Modifier.PUBLIC); emitBind(binderTypeSpec); emitAssign(binderTypeSpec); JavaFile javaFile = JavaFile.builder(target.classPackage, binderTypeSpec.build()) .addFileComment("Generated code from Dart. Do not modify!") .build(); return javaFile.toString(); }
/** * Write a companion class for {@code type} that extends {@link StaticInjection}. */ private void generateStaticInjection(TypeElement type, List<Element> fields) throws IOException { ClassName typeName = ClassName.get(type); ClassName adapterClassName = adapterName(ClassName.get(type), STATIC_INJECTION_SUFFIX); TypeSpec.Builder result = TypeSpec.classBuilder(adapterClassName.simpleName()) .addOriginatingElement(type) .addJavadoc(AdapterJavadocs.STATIC_INJECTION_TYPE, type) .addModifiers(PUBLIC, FINAL) .superclass(StaticInjection.class); for (Element field : fields) { result.addField(memberBindingField(false, field)); } result.addMethod(attachMethod(null, fields, false, typeName, null, true)); result.addMethod(staticInjectMethod(fields, typeName)); String packageName = getPackage(type).getQualifiedName().toString(); JavaFile javaFile = JavaFile.builder(packageName, result.build()) .addFileComment(AdapterJavadocs.GENERATED_BY_DAGGER) .build(); javaFile.writeTo(processingEnv.getFiler()); }
public void generate(Filer filer) throws IOException { JavaFile.builder(classStructure.getClassDetail().getPackageName(), classStructure.getClassBuilder().build()) .build() .writeTo(filer); } }
JavaFile from(ProvidersClass providersClass) throws IOException { List<MethodSpec> methodSpecs = new ArrayList<>(); for (ProvidersClass.Method method : providersClass.methods) { methodSpecs.add(getActionProvider(providersClass.className, method)); } TypeSpec typeSpec = classProviders(providersClass.className, methodSpecs); return JavaFile.builder(providersClass.className.packageName(), typeSpec) .build(); }
public String generateCode(String typeName, String profile) throws IOException { Schema schema = schema(); JavaGenerator javaGenerator = JavaGenerator.get(schema); if (profile != null) { javaGenerator = javaGenerator.withProfile(profile(profile)); } Type type = schema.getType(typeName); TypeSpec typeSpec = javaGenerator.generateType(type); ClassName typeName1 = javaGenerator.generatedTypeName(type); return JavaFile.builder(typeName1.packageName(), typeSpec).build().toString(); }
private String toString(TypeSpec typeSpec) throws IOException { StringBuilder result = new StringBuilder(); JavaFile javaFile = JavaFile.builder("squareup.wire.sample", typeSpec) .build(); javaFile.writeTo(result); return result.toString(); } }
protected void generate(SpecModel specModel, EnumSet<RunMode> runMode) throws IOException { final String packageName = getPackageName(specModel.getComponentTypeName()); JavaFile.builder(packageName, specModel.generate(runMode)) .skipJavaLangImports(true) .build() .writeTo(processingEnv.getFiler()); }
JavaFile brewJava(int sdk, boolean debuggable) { TypeSpec bindingConfiguration = createType(sdk, debuggable); return JavaFile.builder(bindingClassName.packageName(), bindingConfiguration) .addFileComment("Generated code from Butter Knife. Do not modify!") .build(); }