private FileObject createMetadataResource() throws IOException { return this.environment.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", METADATA_PATH); }
public ServiceLoaderGenerator(ProcessingEnvironment environment, String shadowPackage) { this.filer = environment.getFiler(); this.messager = environment.getMessager(); this.shadowPackage = shadowPackage; }
public ShadowProviderGenerator(RobolectricModel model, ProcessingEnvironment environment, String shadowPackage, boolean shouldInstrumentPackages) { this.messager = environment.getMessager(); this.filer = environment.getFiler(); this.model = model; this.shadowPackage = shadowPackage; this.shouldInstrumentPackages = shouldInstrumentPackages; }
@Provides @Singleton public Filer getFiler(ProcessingEnvironment processingEnvironment){ return processingEnvironment.getFiler(); }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); mFiler = processingEnv.getFiler(); mElementUtils = processingEnv.getElementUtils(); mMessager = processingEnv.getMessager(); mIsFileCreated = false; }
private FileObject getMetadataResource() throws IOException { return this.environment.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", METADATA_PATH); }
private void write(TypeElement c) throws IOException { FileObject f = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", "META-INF/services/hudson.Plugin"); try (Writer w = new OutputStreamWriter(f.openOutputStream(), "UTF-8")) { w.write(c.getQualifiedName().toString()); } }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); filer = processingEnv.getFiler(); messager = processingEnv.getMessager(); documentor = new Documentor(processingEnv); }
@Override public synchronized void init(ProcessingEnvironment env) { super.init(env); mElementUtils = env.getElementUtils(); mTypeUtils = env.getTypeUtils(); mFiler = env.getFiler(); mJsonObjectMap = new HashMap<>(); mProcessors = Processor.allProcessors(processingEnv); }
/** {@inheritDoc} */ @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); try { FileObject manifest = processingEnv .getFiler() .createResource(StandardLocation.SOURCE_OUTPUT, "", "bugPatterns.txt"); pw = new PrintWriter(new OutputStreamWriter(manifest.openOutputStream(), UTF_8)); } catch (IOException e) { throw new RuntimeException(e); } }
@Override public synchronized void init(ProcessingEnvironment env) { super.init(env); String sdk = env.getOptions().get(OPTION_SDK_INT); if (sdk != null) { try { this.sdk = Integer.parseInt(sdk); } catch (NumberFormatException e) { env.getMessager() .printMessage(Kind.WARNING, "Unable to parse supplied minSdk option '" + sdk + "'. Falling back to API 1 support."); } } debuggable = !"false".equals(env.getOptions().get(OPTION_DEBUGGABLE)); typeUtils = env.getTypeUtils(); filer = env.getFiler(); try { trees = Trees.instance(processingEnv); } catch (IllegalArgumentException ignored) { } }
private void createBuilderInterface(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder interfaceBuilder = TypeSpec.interfaceBuilder(builderVisibleName) .addModifiers(Modifier.PUBLIC) .addSuperinterface(ConfigurationBuilder.class); final TypeName baseAnnotation = TypeName.get(this.baseAnnotation.asType()); Strings.addClassJavadoc(interfaceBuilder, baseAnnotation); ClassName builder = ClassName.get(PACKAGE, builderVisibleName); elements.stream().filter(BuilderElement.Interface.class::isInstance).map(BuilderElement.Interface.class::cast) .forEach(element -> element.addToBuilderInterface(interfaceBuilder, builder)); Strings.writeClass(processingEnv.getFiler(), interfaceBuilder.build()); }
private void createConfigClass(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder classBuilder = TypeSpec.classBuilder(configName) .addSuperinterface(Serializable.class) .addSuperinterface(org.acra.config.Configuration.class) .addModifiers(Modifier.PUBLIC, Modifier.FINAL); Strings.addClassJavadoc(classBuilder, ClassName.get(baseAnnotation.asType())); final MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC) .addParameter(ParameterSpec.builder(ClassName.get(PACKAGE, builderName), PARAM_0).addAnnotation(Types.NON_NULL).build()); elements.stream().filter(ConfigElement.class::isInstance).map(ConfigElement.class::cast).forEach(element -> element.addToConfig(classBuilder, constructor)); classBuilder.addMethod(constructor.build()); Strings.writeClass(processingEnv.getFiler(), classBuilder.build()); }
void writeClass(String packageName, TypeSpec clazz) { try { debugLog("Writing class:\n" + clazz); JavaFile.builder(packageName, clazz).build().writeTo(processingEnv.getFiler()); } catch (Throwable e) { throw new RuntimeException(e); } }
void writeDotFile(TypeElement module, Map<String, Binding<?>> bindings) throws IOException { JavaFileManager.Location location = StandardLocation.SOURCE_OUTPUT; String path = getPackage(module).getQualifiedName().toString(); String file = module.getQualifiedName().toString().substring(path.length() + 1) + ".dot"; FileObject resource = processingEnv.getFiler().createResource(location, path, file, module); Writer writer = resource.openWriter(); GraphVizWriter dotWriter = new GraphVizWriter(writer); new GraphVisualizer().write(bindings, dotWriter); dotWriter.close(); }
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()); }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (!processed) { processed = true; try (Writer writer = processingEnv.getFiler() .createSourceFile(generatedClassName) .openWriter()) { writer.append(generatedSource); } catch (IOException e) { throw new RuntimeException(e); } } return false; } }
private String collectData(ProcessingEnvironment procEnv) { StringBuilder message = new StringBuilder(); message.append("Problem report for usages of 'lombok.javac.apt.Processor'\n\n"); listOptions(message, procEnv); findServices(message, procEnv.getFiler()); addStacktrace(message); listProperties(message); return message.toString(); }
private void createFactoryClass() throws IOException { final TypeName configurationBuilderFactory = Types.CONFIGURATION_BUILDER_FACTORY; Strings.writeClass(processingEnv.getFiler(), TypeSpec.classBuilder(factoryName) .addModifiers(Modifier.PUBLIC) .addSuperinterface(configurationBuilderFactory) .addAnnotation(AnnotationSpec.builder(AutoService.class).addMember("value", "$T.class", configurationBuilderFactory).build()) .addMethod(Types.overriding(Types.getOnlyMethod(processingEnv, Strings.CONFIGURATION_BUILDER_FACTORY)) .addAnnotation(Types.NON_NULL) .addStatement("return new $T($L)", ClassName.get(PACKAGE, builderName), PARAM_0) .build()) .build()); } }
private void generateSources(ModelProcessor.ProcessResult processResult) throws IOException { timeStats.start("Generate Sources"); LOGGER.info("Number of files generated by AndroidAnnotations: {}", processResult.codeModel.countArtifacts()); CodeModelGenerator modelGenerator = new CodeModelGenerator(processingEnv.getFiler(), coreVersion, androidAnnotationsEnv.getOptionValue(CodeModelGenerator.OPTION_ENCODING)); modelGenerator.generate(processResult); timeStats.stop("Generate Sources"); }