@Override public OutputStream openBinary(JPackage pkg, String fileName) throws IOException { String qualifiedClassName = toQualifiedClassName(pkg, fileName); try { JavaFileObject sourceFile; sourceFile = filer.createSourceFile(qualifiedClassName, mElements); return sourceFile.openOutputStream(); } catch (FilerException e) { /* * 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; } }
@Override public FileObject getResource(Location location, CharSequence pkg, CharSequence relativeName) throws IOException { validateName(relativeName); FileObject fo = _fileManager.getFileForInput( location, pkg.toString(), relativeName.toString()); if (fo == null) { throw new FileNotFoundException("Resource does not exist : " + location + '/' + pkg + '/' + relativeName); //$NON-NLS-1$ } URI uri = fo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Resource already created : " + location + '/' + pkg + '/' + relativeName); //$NON-NLS-1$ } _createdFiles.add(uri); return fo; }
public Image loadImage(String filename, boolean createByteBuffer) { logger.info("Loading: " + filename); Image image = new Image(); try { BufferedImage bi = ImageIO.read(FileSystem.getStream(filename)); if (bi != null && bi.getColorModel() != null) { image.format = bi.getColorModel().hasAlpha() ? GL_RGBA : GL_RGB; image.data = createByteBuffer(bi); image.image = bi; } else { throw new FilerException(filename); } } catch (Exception e) { logger.warn("Failed to load image: " + e.getMessage()); return noImage; } return image; }
@Override public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject sourceFile = fileManager.getJavaFileForOutput(StandardLocation.SOURCE_OUTPUT, name.toString(), JavaFileObject.Kind.SOURCE, null); if (!createdResources.add(sourceFile.toUri())) { throw new FilerException("Attempt to recreate file for type " + name); } return new JavaFileObjectImpl(sourceFile, new FileObjectDelegate() { private boolean closed = false; @Override protected void onClose(Output<File> generatedSource) { if (!closed) { closed = true; // TODO optimize if the regenerated sources didn't change compared the previous build CompilationUnit unit = new CompilationUnit(null, generatedSource.getResource().getAbsolutePath(), null /* encoding */); processingEnv.addNewUnit(unit); incrementalCompiler.addGeneratedSource(generatedSource); } } }); }
@Test public void testRecreateSourceFile() throws Exception { EclipseFileManager fileManager = new EclipseFileManager(null, Charsets.UTF_8); File outputDir = temp.newFolder(); fileManager.setLocation(StandardLocation.SOURCE_OUTPUT, Collections.singleton(outputDir)); FilerImpl filer = new FilerImpl(null /* context */, fileManager, null /* compiler */, null /* env */); filer.createSourceFile("test.Source"); try { filer.createSourceFile("test.Source"); Assert.fail(); } catch (FilerException expected) { // From Filer javadoc: // @throws FilerException if the same pathname has already been // created, the same type has already been created, or the name is // not valid for a type } }
private void checkName(String name, boolean allowUnnamedPackageInfo) throws FilerException { if (!SourceVersion.isName(name) && !isPackageInfo(name, allowUnnamedPackageInfo)) { if (lint) log.warning("proc.illegal.file.name", name); throw new FilerException("Illegal name " + name); } }
private void checkNameAndExistence(String typename, boolean allowUnnamedPackageInfo) throws FilerException { // TODO: Check if type already exists on source or class path? // If so, use warning message key proc.type.already.exists checkName(typename, allowUnnamedPackageInfo); if (aggregateGeneratedSourceNames.contains(typename) || aggregateGeneratedClassNames.contains(typename)) { if (lint) log.warning("proc.type.recreate", typename); throw new FilerException("Attempt to recreate a file for type " + typename); } }
/** * Check to see if the file has already been opened; if so, throw * an exception, otherwise add it to the set of files. */ private void checkFileReopening(FileObject fileObject, boolean addToHistory) throws FilerException { for(FileObject veteran : fileObjectHistory) { if (fileManager.isSameFile(veteran, fileObject)) { if (lint) log.warning("proc.file.reopening", fileObject.getName()); throw new FilerException("Attempt to reopen a file for path " + fileObject.getName()); } } if (addToHistory) fileObjectHistory.add(fileObject); }
/** * Determines if a given exception is (most likely) caused by * <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367599">Bug 367599</a>. */ public static boolean isBug367599(Throwable t) { if (t instanceof FilerException) { for (StackTraceElement ste : t.getStackTrace()) { if (ste.toString().contains("org.eclipse.jdt.internal.apt.pluggable.core.filer.IdeFilerImpl.create")) { // See: https://bugs.eclipse.org/bugs/show_bug.cgi?id=367599 return true; } } } if (t.getCause() != null) { return isBug367599(t.getCause()); } return false; }
/** * Determines if a given exception is (most likely) caused by * <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367599">Bug 367599</a>. */ private static boolean isBug367599(Throwable t) { if (t instanceof FilerException) { for (StackTraceElement ste : t.getStackTrace()) { if (ste.toString().contains("org.eclipse.jdt.internal.apt.pluggable.core.filer.IdeFilerImpl.create")) { // See: https://bugs.eclipse.org/bugs/show_bug.cgi?id=367599 return true; } } } return t.getCause() != null && isBug367599(t.getCause()); }
/** * Generates a source file from the specified {@link io.sundr.codegen.model.TypeDef}. * @param model The model of the class to generate. * @param resourceName The template to use. * @throws IOException */ public void generateFromClazz(TypeDef model, String resourceName) throws IOException { try { generateFromClazz(model, processingEnv .getFiler() .createSourceFile(model.getFullyQualifiedName()), resourceName); } catch (FilerException e) { //TODO: Need to avoid dublicate interfaces here. } }
@Override public JavaFileObject createClassFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject jfo = _fileManager.getJavaFileForOutput( StandardLocation.CLASS_OUTPUT, name.toString(), JavaFileObject.Kind.CLASS, null); URI uri = jfo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Class file already created : " + name); //$NON-NLS-1$ } _createdFiles.add(uri); return new HookedJavaFileObject(jfo, jfo.getName(), name.toString(), this); }
@Override public FileObject createResource(Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements) throws IOException { validateName(relativeName); FileObject fo = _fileManager.getFileForOutput( location, pkg.toString(), relativeName.toString(), null); URI uri = fo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Resource already created : " + location + '/' + pkg + '/' + relativeName); //$NON-NLS-1$ } _createdFiles.add(uri); return fo; }
@Override public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject jfo = _fileManager.getJavaFileForOutput( StandardLocation.SOURCE_OUTPUT, name.toString(), JavaFileObject.Kind.SOURCE, null); URI uri = jfo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Source file already created : " + name); //$NON-NLS-1$ } _createdFiles.add(uri); // hook the file object's writers to create compilation unit and add to addedUnits() return new HookedJavaFileObject(jfo, jfo.getName(), name.toString(), this); }
@Override public JavaFileObject createClassFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject jfo = _fileManager.getJavaFileForOutput( StandardLocation.CLASS_OUTPUT, name.toString(), JavaFileObject.Kind.CLASS, null); URI uri = jfo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Class file already created : " + name); //$NON-NLS-1$ } _createdFiles.add(uri); return new HookedJavaFileObject(jfo, jfo.getName(), this); }
@Override public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject jfo = _fileManager.getJavaFileForOutput( StandardLocation.SOURCE_OUTPUT, name.toString(), JavaFileObject.Kind.SOURCE, null); URI uri = jfo.toUri(); if (_createdFiles.contains(uri)) { throw new FilerException("Source file already created : " + name); //$NON-NLS-1$ } _createdFiles.add(uri); // hook the file object's writers to create compilation unit and add to addedUnits() return new HookedJavaFileObject(jfo, jfo.getName(), this); }
@Override public JavaFileObject createClassFile(CharSequence name, Element... originatingElements) throws IOException { JavaFileObject classFile = fileManager.getJavaFileForOutput(StandardLocation.CLASS_OUTPUT, name.toString(), JavaFileObject.Kind.CLASS, null); if (!createdResources.add(classFile.toUri())) { throw new FilerException("Attempt to recreate file for class " + name); } return new JavaFileObjectImpl(classFile, new FileObjectDelegate() { @Override protected void onClose(Output<File> generatedClass) { // TODO processingEnv.addNewClassFile throw new UnsupportedOperationException(); } }); }
@Override public FileObject createResource(Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements) throws IOException { FileObject file = fileManager.getFileForOutput(location, pkg.toString(), relativeName.toString(), null); if (!createdResources.add(file.toUri())) { throw new FilerException("Attempt to recreate file for resource " + pkg + "." + relativeName); } return new FileObjectImpl(file, new FileObjectDelegate()); }
@Override public FileObject getResource(Location location, CharSequence pkg, CharSequence relativeName) throws IOException { FileObject file = fileManager.getFileForInput(location, pkg.toString(), relativeName.toString()); if (file == null) { throw new FileNotFoundException("Resource does not exist " + location + '/' + pkg + '/' + relativeName); } if (createdResources.contains(file.toUri())) { throw new FilerException("Resource already created " + pkg + "." + relativeName); } return file; }
private void checkName(String name) throws FilerException { checkName(name, false); }
private void tryGenerateContextPathHolder() throws IOException { try { new ContextPathHolderWriter(processingEnv.getFiler()).write(CONTEXT_PATH_HOLDER); } catch (FilerException ignored) { } }
