/** 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; } }
String myPackage = period > 0 ? index.substring(0, period) : null; String clazz = index.substring(period + 1); writer = new BufferedWriter(sourceFile.openWriter()); if (myPackage != null) { writer.write("package " + myPackage + ";\n\n");
@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(); try { PrintWriter pw = new PrintWriter(writer);
@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 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; } }
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); } }
@Override public void close() throws IOException { try { formatter.formatSource( CharSource.wrap(stringBuilder), new CharSink() { @Override public Writer openStream() throws IOException { return fileObject.openWriter(); } }); } catch (FormatterException e) { // An exception will happen when the code being formatted has an error. It's better to // log the exception and emit unformatted code so the developer can view the code which // caused a problem. try (Writer writer = fileObject.openWriter()) { writer.append(stringBuilder.toString()); } if (messager != null) { messager.printMessage(Diagnostic.Kind.NOTE, "Error formatting " + getName()); } } } };
@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(); try { SerializerConfig serializerConfig = conf.getSerializerConfig(model);
JavaFileObject jfo = filer.createSourceFile(FragmentArgs.AUTO_MAPPING_QUALIFIED_CLASS, element); Writer writer = jfo.openWriter(); JavaWriter jw = new JavaWriter(writer);
Writer writer = jfo.openWriter(); jw = new JavaWriter(writer); writePackage(jw, fragmentClass);
public Writer openSource(JPackage pkg, String fileName) throws IOException { String name; if(pkg.isUnnamed()) name = fileName; else name = pkg.name()+'.'+fileName; name = name.substring(0,name.length()-5); // strip ".java" return filer.createSourceFile(name).openWriter(); }
private void passSourceCodeToCompiler(String code) { try { processingEnv.getFiler() .createSourceFile(getTypeName(code)) .openWriter() .append(code) .close(); } catch (IOException e) { elementFuture.setException(e); } } }
@Before public void setup() throws IOException { originatingElement = newTopLevelClass("com.example.Foo").asElement(); when(filer.createSourceFile(eq("com.example.Bar"), (Element[]) any())).thenReturn(sourceFile); when(sourceFile.openWriter()).thenReturn(source); }
@Test public void testFailuresSuppressed() throws IOException { Writer mockWriter = Mockito.mock(Writer.class); doThrow(new IOException("Error appending")).when(mockWriter).append(any()); doThrow(new IOException("Error closing")).when(mockWriter).close(); when(sourceFile.openWriter()).thenReturn(mockWriter); thrown.expect(IOException.class); thrown.expectMessage("Error appending"); thrown.expect(suppressed(instanceOf(IOException.class))); thrown.expect(suppressed(hasProperty("message", equalTo("Error closing")))); FilerUtils.writeCompilationUnit(filer, unit, originatingElement); }