@Override public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements) throws IOException { return new FormattingJavaFileObject( delegate.createSourceFile(name, originatingElements), formatter, messager); }
/** Writes this to {@code filer}. */ public void writeTo(Filer filer) throws IOException { String fileName = packageName.isEmpty() ? typeSpec.name : packageName + "." + typeSpec.name; List<Element> originatingElements = typeSpec.originatingElements; JavaFileObject filerSourceFile = filer.createSourceFile(fileName, originatingElements.toArray(new Element[originatingElements.size()])); try (Writer writer = filerSourceFile.openWriter()) { writeTo(writer); } catch (Exception e) { try { filerSourceFile.delete(); } catch (Exception ignored) { } throw e; } }
@Override public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements) throws IOException { return delegate().createSourceFile(name, originatingElements); }
private void createInfoIndexFile(String index) { BufferedWriter writer = null; try { JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(index); int period = index.lastIndexOf('.'); String myPackage = period > 0 ? index.substring(0, period) : null;
@Override public void generate() { if (shadowPackage == null) { return; } final String shadowClassName = shadowPackage + '.' + GEN_CLASS; // TODO: Because this was fairly simple to begin with I haven't // included a templating engine like Velocity but simply used // raw print() statements, in an effort to reduce the number of // dependencies that RAP has. However, if it gets too complicated // then using Velocity might be a good idea. try { JavaFileObject jfo = filer.createSourceFile(shadowClassName); try (PrintWriter writer = new PrintWriter(jfo.openWriter())) { generate(writer); } } catch (IOException e) { messager.printMessage(Diagnostic.Kind.ERROR, "Failed to write shadow class file: " + e); throw new RuntimeException(e); } }
JavaFileObject fileObject = processingEnv.getFiler().createSourceFile(applicationPackageName + "." + applicationClassName); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Creating " + fileObject.toUri()); Writer writer = fileObject.openWriter();
@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; } }
void complete() { CharSequence sourceCode = extractSourceCode(); try { JavaFileObject sourceFile = key.originatingElement != null ? getFiler().createSourceFile(key.toString(), key.originatingElement) : getFiler().createSourceFile(key.toString()); try (Writer writer = sourceFile.openWriter()) { writer.append(sourceCode); } } catch (FilerException ex) { if (identicalFileIsAlreadyGenerated(sourceCode)) { getMessager().printMessage(Kind.MANDATORY_WARNING, "Regenerated file with the same content: " + key); } else { getMessager().printMessage(Kind.MANDATORY_WARNING, String.format( "Generated source file name colission. Attempt to overwrite already generated file: %s, %s." + " If this happens when using @Value.Immutable on same-named nested classes in the same package," + " use can use @Value.Enclosing annotation to provide some sort of namespacing", key, ex)); } } catch (IOException ex) { throw Throwables.propagate(ex); } }
private void generate(Set<ClassModel> classModels) { final Filer filer = processingEnv.getFiler(); for (ClassModel classModel : classModels) { final String derivedClassName = deriveClassName(classModel); final String code = Generator.generate(derivedClassName, classModel); final String fqn = (classModel.hasDefaultPackage() ? "" : classModel.getPackageName() + ".") + derivedClassName; try (final Writer writer = filer.createSourceFile(fqn, classModel.typeElement()).openWriter()) { writer.write(code); } catch (IOException x) { throw new Error("Error writing " + fqn, x); } } }
public void writeFile(BaseGenerator generator, Element... originatingElements) throws IOException { Writer writer = null; try { JavaFileObject jfo = filer.createSourceFile(generator.getFqcn(), originatingElements); writer = jfo.openWriter(); if (isDebugEnabled) { System.out.println("File generated:\n" + generator.brewJava() + "---"); } writer.write(generator.brewJava()); } finally { if (writer != null) { writer.close(); } } } }
@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) { try { for (Processor processor : mProcessors) { processor.findAndParseObjects(env, mJsonObjectMap, mElementUtils, mTypeUtils); } for (Map.Entry<String, JsonObjectHolder> entry : mJsonObjectMap.entrySet()) { String fqcn = entry.getKey(); JsonObjectHolder jsonObjectHolder = entry.getValue(); if (!jsonObjectHolder.fileCreated) { jsonObjectHolder.fileCreated = true; try { JavaFileObject jfo = mFiler.createSourceFile(fqcn); Writer writer = jfo.openWriter(); writer.write(new ObjectMapperInjector(jsonObjectHolder).getJavaClassFile()); writer.flush(); writer.close(); } catch (IOException e) { error(fqcn, "Exception occurred while attempting to write injector for type %s. Exception message: %s", fqcn, e.getMessage()); } } } return true; } catch (Throwable e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); error("Exception while processing Json classes. Stack trace incoming:\n%s", stackTrace.toString()); return false; } }
FileObject fo = context.getProcessingEnvironment().getFiler().createSourceFile( getFullyQualifiedClassName( entity, metaModelPackage ) );
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { map.clear(); if (!isAnnotatedWithClass(roundEnv, PermissionsRequestSync.class)) return false; if (!isAnnotatedWithMethod(roundEnv, PermissionsNonRationale.class)) return false; if (!isAnnotatedWithMethod(roundEnv, PermissionsGranted.class)) return false; if (!isAnnotatedWithMethod(roundEnv, PermissionsDenied.class)) return false; if (!isAnnotatedWithMethod(roundEnv, PermissionsRationale.class)) return false; if (!isAnnotatedWithMethod(roundEnv, PermissionsCustomRationale.class)) return false; Writer writer = null; for (ProxyInfo info : map.values()) { try { JavaFileObject file = mFiler.createSourceFile(info.getProxyName(), info.getElement()); writer = file.openWriter(); writer.write(info.generateJavaCode()); writer.flush(); } catch (IOException e) { e.printStackTrace(); } finally { if (writer != null) { try { writer.close(); } catch (IOException e) { e.printStackTrace(); } } } } return true; }
private void generateTemplateType(TypeElement templateType) throws IOException, Exception { SwissArmyKnife knife = new SwissArmyKnife(processingEnv, templateType); String string = readTemplateResource(templateType, knife); Unit unit = parseUnit(string); Unit resolved = transformUnit(knife, unit); TemplateWriter writingTransformer = new TemplateWriter(knife, templateType, GeneratedTypes.getSimpleName(templateType)); CharSequence template = writingTransformer.toCharSequence(resolved); JavaFileObject templateFile = knife.environment.getFiler().createSourceFile( GeneratedTypes.getQualifiedName(knife.elements, templateType), templateType); try (Writer writer = templateFile.openWriter()) { writer.append(template); } }
Writer w = processingEnv.getFiler().createSourceFile(fqn, elements).openWriter(); try { PrintWriter pw = new PrintWriter(w);
JavaFileObject fileObject = processingEnv.getFiler().createSourceFile(className, elements.toArray(new Element[elements.size()])); Writer writer = fileObject.openWriter();
@Override public OutputStream openBinary(JPackage pkg, String fileName) throws IOException { String qualifiedClassName = toQualifiedClassName(pkg, fileName); LOGGER.debug("Generating class: {}", qualifiedClassName); Element[] classOriginatingElements = originatingElements.getClassOriginatingElements(qualifiedClassName); try { JavaFileObject sourceFile; if (classOriginatingElements.length == 0) { LOGGER.info("Generating class with no originating element: {}", qualifiedClassName); } sourceFile = filer.createSourceFile(qualifiedClassName, classOriginatingElements); return sourceFile.openOutputStream(); } catch (FilerException e) { LOGGER.error("Could not generate source file for {} due to error: {}", qualifiedClassName, e.getMessage()); /* * This exception is expected, when some files are created twice. We cannot * delete existing files, unless using a dirty hack. Files a created twice when * the same file is created from different annotation rounds. Happens when * renaming classes, and for Background executor. It also probably means I * didn't fully understand how annotation processing works. If anyone can point * me out... */ return VOID_OUTPUT_STREAM; } }
filer.createSourceFile(FragmentArgs.AUTO_MAPPING_QUALIFIED_CLASS, element); Writer writer = jfo.openWriter(); JavaWriter jw = new JavaWriter(writer);
origHelper = orig; jfo = filer.createSourceFile(qualifiedBuilderName, orig); Writer writer = jfo.openWriter(); jw = new JavaWriter(writer);
private void passSourceCodeToCompiler(String code) { try { processingEnv.getFiler() .createSourceFile(getTypeName(code)) .openWriter() .append(code) .close(); } catch (IOException e) { elementFuture.setException(e); } } }