This interface supports the creation of new files by an annotation processor. Files created in this way will be known to the annotation processing tool implementing this interface, better enabling the tool to manage them. Source and class files so created will be
considered for processing by the tool in a subsequent
round of processing after the
close
method has been called on the
Writer
or
OutputStream
used to write the contents of the file. Three kinds of files are distinguished: source files, class files, and auxiliary resource files.
There are two distinguished supported locations (subtrees within the logical file system) where newly created files are placed: one for new source files , and one for new class files . (These might be specified on a tool's command line, for example, using flags such as -s
and -d
.) The actual locations for new source files and new class files may or may not be distinct on a particular run of the tool. Resource files may be created in either location. The methods for reading and writing resources take a relative name argument. A relative name is a non-null, non-empty sequence of path segments separated by '/'
; '.'
and '..'
are invalid path segments. A valid relative name must match the "path-rootless" rule of RFC 3986 , section 3.3.
The file creation methods take a variable number of arguments to allow the originating elements to be provided as hints to the tool infrastructure to better manage dependencies. The originating elements are the types or packages (representing package-info
files) or modules (representing module-info
files) which caused an annotation processor to attempt to create a new file. For example, if an annotation processor tries to create a source file, GeneratedFromUserSource
, in response to processing
@Generate
public class UserSource {}
the type element for
UserSource
should be passed as part of the creation method call as in:
filer.createSourceFile("GeneratedFromUserSource",
eltUtils.getTypeElement("UserSource"));
If there are no originating elements, none need to be passed. This information may be used in an incremental environment to determine the need to rerun processors or remove generated files. Non-incremental environments may ignore the originating element information.
During each run of an annotation processing tool, a file with a given pathname may be created only once. If that file already exists before the first attempt to create it, the old contents will be deleted. Any subsequent attempt to create the same file during a run will throw a FilerException
, as will attempting to create both a class file and source file for the same type name or same package name. The initial inputs to the tool are considered to be created by the zeroth round; therefore, attempting to create a source or class file corresponding to one of those inputs will result in a FilerException
.
In general, processors must not knowingly attempt to overwrite existing files that were not generated by some processor. A Filer
may reject attempts to open a file corresponding to an existing type, like java.lang.Object
. Likewise, the invoker of the annotation processing tool must not knowingly configure the tool such that the discovered processors will attempt to overwrite existing files that were not generated.
Processors can indicate a source or class file is generated by including a javax.annotation.Generated
annotation if the environment is configured so that that type is accessible.