src.java.compiler.share.classes.javax.tools.StandardJavaFileManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of nb-javac Show documentation
Show all versions of nb-javac Show documentation
"nb-javac" is a patched version of OpenJDK "javac", i.e., the Java compiler. This has long been part of NetBeans, providing a highly tuned Java compiler specifically for the Java editor i.e., parsing and lexing for features such as syntax coloring, code completion.
The newest version!
/*
* Copyright (c) 2006, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.tools;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* File manager based on {@link File java.io.File} and {@link Path java.nio.file.Path}.
*
* A common way to obtain an instance of this class is using
* {@linkplain JavaCompiler#getStandardFileManager getStandardFileManager}, for example:
*
*
* JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
* {@code DiagnosticCollector} diagnostics =
* new {@code DiagnosticCollector()};
* StandardJavaFileManager fm = compiler.getStandardFileManager(diagnostics, null, null);
*
*
* This file manager creates file objects representing regular
* {@linkplain File files},
* {@linkplain java.util.zip.ZipEntry zip file entries}, or entries in
* similar file system based containers. Any file object returned
* from a file manager implementing this interface must observe the
* following behavior:
*
*
* -
* File names need not be canonical.
*
* -
* For file objects representing regular files
*
* -
* the method
{@linkplain FileObject#delete()}
* is equivalent to {@linkplain File#delete()},
*
* -
* the method
{@linkplain FileObject#getLastModified()}
* is equivalent to {@linkplain File#lastModified()},
*
* -
* the methods
{@linkplain FileObject#getCharContent(boolean)},
* {@linkplain FileObject#openInputStream()}, and
* {@linkplain FileObject#openReader(boolean)}
* must succeed if the following would succeed (ignoring
* encoding issues):
*
* new {@linkplain java.io.FileInputStream#FileInputStream(File) FileInputStream}(new {@linkplain File#File(java.net.URI) File}({@linkplain FileObject fileObject}.{@linkplain FileObject#toUri() toUri}()))
*
*
* -
* and the methods
*
{@linkplain FileObject#openOutputStream()}, and
* {@linkplain FileObject#openWriter()} must
* succeed if the following would succeed (ignoring encoding
* issues):
*
* new {@linkplain java.io.FileOutputStream#FileOutputStream(File) FileOutputStream}(new {@linkplain File#File(java.net.URI) File}({@linkplain FileObject fileObject}.{@linkplain FileObject#toUri() toUri}()))
*
*
*
*
* -
* The {@linkplain java.net.URI URI} returned from
*
{@linkplain FileObject#toUri()}
*
* -
* must be {@linkplain java.net.URI#isAbsolute() absolute} (have a schema), and
*
* -
* must have a {@linkplain java.net.URI#normalize() normalized}
* {@linkplain java.net.URI#getPath() path component} which
* can be resolved without any process-specific context such
* as the current directory (file names must be absolute).
*
*
*
*
*
* According to these rules, the following URIs, for example, are
* allowed:
*
* -
*
file:///C:/Documents%20and%20Settings/UncleBob/BobsApp/Test.java
*
* -
*
jar:///C:/Documents%20and%20Settings/UncleBob/lib/vendorA.jar!/com/vendora/LibraryClass.class
*
*
* Whereas these are not (reason in parentheses):
*
* -
*
file:BobsApp/Test.java (the file name is relative
* and depend on the current directory)
*
* -
*
jar:lib/vendorA.jar!/com/vendora/LibraryClass.class
* (the first half of the path depends on the current directory,
* whereas the component after ! is legal)
*
* -
*
Test.java (this URI depends on the current
* directory and does not have a schema)
*
* -
*
jar:///C:/Documents%20and%20Settings/UncleBob/BobsApp/../lib/vendorA.jar!com/vendora/LibraryClass.class
* (the path is not normalized)
*
*
*
* All implementations of this interface must support Path objects representing
* files in the {@linkplain java.nio.file.FileSystems#getDefault() default file system.}
* It is recommended that implementations should support Path objects from any filesystem.
*
*
* @apiNote
* Some methods on this interface take a {@code Collection}
* instead of {@code Iterable}.
* This is to prevent the possibility of accidentally calling the method
* with a single {@code Path} as such an argument, because although
* {@code Path} implements {@code Iterable}, it would almost never be
* correct to call these methods with a single {@code Path} and have it be treated as
* an {@code Iterable} of its components.
*
*
* @author Peter von der Ahé
* @since 1.6
*/
public interface StandardJavaFileManager extends JavaFileManager {
/**
* Compares two file objects and return true if they represent the
* same canonical file, zip file entry, or entry in any file
* system based container.
*
* @param a a file object
* @param b a file object
* @return true if the given file objects represent the same
* canonical file, zip file entry or path; false otherwise
*
* @throws IllegalArgumentException if either of the arguments
* were created with another file manager implementation
*/
@Override
boolean isSameFile(FileObject a, FileObject b);
/**
* Returns file objects representing the given files.
*
* @param files a list of files
* @return a list of file objects
* @throws IllegalArgumentException if the list of files includes
* a directory
*/
Iterable getJavaFileObjectsFromFiles(
Iterable files);
/**
* Returns file objects representing the given paths.
*
* @implSpec
* The default implementation lazily converts each path to a file and calls
* {@link #getJavaFileObjectsFromFiles(Iterable) getJavaFileObjectsFromFiles}.
* {@code IllegalArgumentException} will be thrown
* if any of the paths cannot be converted to a file at the point the conversion happens.
*
* @param paths a list of paths
* @return a list of file objects
* @throws IllegalArgumentException if the list of paths includes
* a directory or if this file manager does not support any of the
* given paths
*
* @since 13
*/
default Iterable getJavaFileObjectsFromPaths(
Collection paths) {
return getJavaFileObjectsFromFiles(() -> new Iterator() {
final Iterator iter = paths.iterator();
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public File next() {
Path p = iter.next();
try {
return p.toFile();
} catch (UnsupportedOperationException e) {
throw new IllegalArgumentException(p.toString(), e);
}
}
});
}
/**
* Returns file objects representing the given paths.
*
* @implSpec
* The default implementation lazily converts each path to a file and calls
* {@link #getJavaFileObjectsFromPaths(Collection) getJavaFileObjectsFromPaths}.
* {@code IllegalArgumentException} will be thrown
* if any of the paths cannot be converted to a file at the point the conversion happens.
*
* @param paths a list of paths
* @return a list of file objects
* @throws IllegalArgumentException if the list of paths includes
* a directory or if this file manager does not support any of the
* given paths.
*
* @since 9
* @deprecated use {@link #getJavaFileObjectsFromPaths(Collection)} instead,
* to prevent the possibility of accidentally calling the method with a
* single {@code Path} as such an argument. Although {@code Path} implements
* {@code Iterable}, it would almost never be correct to pass a single
* {@code Path} and have it be treated as an {@code Iterable} of its
* components.
*/
@Deprecated(since = "13")
default Iterable getJavaFileObjectsFromPaths(
Iterable paths) {
if (paths instanceof Collection) {
return getJavaFileObjectsFromPaths((Collection) paths);
}
List result = new ArrayList<>();
for (Path item : paths) {
result.add(item);
}
return getJavaFileObjectsFromPaths(result);
}
/**
* Returns file objects representing the given files.
* Convenience method equivalent to:
*
*
* getJavaFileObjectsFromFiles({@linkplain java.util.Arrays#asList Arrays.asList}(files))
*
*
* @param files an array of files
* @return a list of file objects
* @throws IllegalArgumentException if the array of files includes
* a directory or if this file manager does not support any of the
* given paths
* @throws NullPointerException if the given array contains null
* elements
*/
Iterable getJavaFileObjects(File... files);
/**
* Returns file objects representing the given paths.
* Convenience method equivalent to:
*
*
* getJavaFileObjectsFromPaths({@linkplain java.util.Arrays#asList Arrays.asList}(paths))
*
*
* @implSpec
* The default implementation will only throw {@code NullPointerException}
* if {@linkplain #getJavaFileObjectsFromPaths(Collection)} throws it.
*
* @param paths an array of paths
* @return a list of file objects
* @throws IllegalArgumentException if the array of files includes
* a directory or if this file manager does not support any of the
* given paths
* @throws NullPointerException if the given array contains null
* elements
*
* @since 9
*/
default Iterable getJavaFileObjects(Path... paths) {
return getJavaFileObjectsFromPaths(Arrays.asList(paths));
}
/**
* Returns file objects representing the given file names.
*
* @param names a list of file names
* @return a list of file objects
* @throws IllegalArgumentException if the list of file names
* includes a directory
*/
Iterable getJavaFileObjectsFromStrings(
Iterable names);
/**
* Returns file objects representing the given file names.
* Convenience method equivalent to:
*
*
* getJavaFileObjectsFromStrings({@linkplain java.util.Arrays#asList Arrays.asList}(names))
*
*
* @param names a list of file names
* @return a list of file objects
* @throws IllegalArgumentException if the array of file names
* includes a directory
* @throws NullPointerException if the given array contains null
* elements
*/
Iterable getJavaFileObjects(String... names);
/**
* Associates the given search path with the given location. Any
* previous value will be discarded.
*
* If the location is a module-oriented or output location, any module-specific
* associations set up by {@linkplain #setLocationForModule setLocationForModule}
* will be cancelled.
*
* @param location a location
* @param files a list of files, if {@code null} use the default
* search path for this location
* @see #getLocation
* @throws IllegalArgumentException if {@code location} is an output
* location and {@code files} does not contain exactly one element
* @throws IOException if {@code location} is an output location and
* does not represent an existing directory
*/
void setLocation(Location location, Iterable files)
throws IOException;
/**
* Associates the given search path with the given location.
* Any previous value will be discarded.
*
* If the location is a module-oriented or output location, any module-specific
* associations set up by {@linkplain #setLocationForModule setLocationForModule}
* will be cancelled.
*
* @implSpec
* The default implementation lazily converts each path to a file and calls
* {@link #setLocation setLocation}.
* {@code IllegalArgumentException} will be thrown if any of the paths cannot
* be converted to a file at the point the conversion happens.
*
* @param location a location
* @param paths a list of paths, if {@code null} use the default
* search path for this location
* @see #getLocation
* @throws IllegalArgumentException if {@code location} is an output
* location and {@code paths} does not contain exactly one element
* or if this file manager does not support any of the given paths
* @throws IOException if {@code location} is an output location and
* {@code paths} does not represent an existing directory
*
* @since 9
*/
default void setLocationFromPaths(Location location, Collection paths)
throws IOException {
setLocation(location, () -> new Iterator() {
final Iterator iter = paths.iterator();
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public File next() {
Path p = iter.next();
try {
return p.toFile();
} catch (UnsupportedOperationException e) {
throw new IllegalArgumentException(p.toString(), e);
}
}
});
}
/**
* Associates the given search path with the given module and location,
* which must be a module-oriented or output location.
* Any previous value will be discarded.
* This overrides any default association derived from the search path
* associated with the location itself.
*
* All such module-specific associations will be cancelled if a
* new search path is associated with the location by calling
* {@linkplain #setLocation setLocation} or
* {@linkplain #setLocationFromPaths setLocationFromPaths}.
*
* @throws IllegalStateException if the location is not a module-oriented
* or output location.
* @throws UnsupportedOperationException if this operation is not supported by
* this file manager.
* @throws IOException if {@code location} is an output location and
* {@code paths} does not represent an existing directory
*
* @param location the location
* @param moduleName the name of the module
* @param paths the search path to associate with the location and module.
*
* @see #setLocation
* @see #setLocationFromPaths
*
* @since 9
*/
default void setLocationForModule(Location location, String moduleName,
Collection paths) throws IOException {
throw new UnsupportedOperationException();
}
/**
* Returns the search path associated with the given location.
*
* @param location a location
* @return a list of files or {@code null} if this location has no
* associated search path
* @throws IllegalStateException if any element of the search path
* cannot be converted to a {@linkplain File}, or if the search path
* cannot be represented as a simple series of files.
*
* @see #setLocation
* @see Path#toFile
*/
Iterable getLocation(Location location);
/**
* Returns the search path associated with the given location.
*
* @implSpec
* The default implementation calls {@link #getLocation getLocation}
* and then returns an {@code Iterable} formed by calling {@code toPath()}
* on each {@code File} returned from {@code getLocation}.
*
* @param location a location
* @return a list of paths or {@code null} if this location has no
* associated search path
* @throws IllegalStateException if the search path cannot be represented
* as a simple series of paths.
*
* @see #setLocationFromPaths
* @since 9
*/
default Iterable getLocationAsPaths(Location location) {
return () -> new Iterator() {
final Iterator iter = getLocation(location).iterator();
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public Path next() {
return iter.next().toPath();
}
};
}
/**
* Returns the path, if any, underlying this file object (optional operation).
* File objects derived from a {@link java.nio.file.FileSystem FileSystem},
* including the default file system, typically have a corresponding underlying
* {@link java.nio.file.Path Path} object. In such cases, this method may be
* used to access that object.
*
* @implSpec
* The default implementation throws {@link UnsupportedOperationException}
* for all files.
*
* @param file a file object
* @return a path representing the same underlying file system artifact
* @throws IllegalArgumentException if the file object does not have an underlying path
* @throws UnsupportedOperationException if the operation is not supported by this file manager
*
* @since 9
*/
default Path asPath(FileObject file) {
throw new UnsupportedOperationException();
}
/**
* Factory to create {@code Path} objects from strings.
*
* @since 9
*/
interface PathFactory {
/**
* Converts a path string, or a sequence of strings that when joined form a path string, to a Path.
*
* @param first the path string or initial part of the path string
* @param more additional strings to be joined to form the path string
* @return the resulting {@code Path}
*/
Path getPath(String first, String... more);
}
/**
* Specify a factory that can be used to generate a path from a string, or series of strings.
*
* If this method is not called, a factory whose {@code getPath} method is
* equivalent to calling
* {@link java.nio.file.Paths#get(String, String...) java.nio.file.Paths.get(first, more)}
* will be used.
*
* @implSpec
* The default implementation of this method ignores the factory that is provided.
*
* @param f the factory
*
* @since 9
*/
default void setPathFactory(PathFactory f) {
}
}