Home » openjdk-7 » com.sun.tools.javac.nio » [javadoc | source]

com.sun.tools.javac.nio
public class: JavacPathFileManager [javadoc | source]

java.lang.Object
   com.sun.tools.javac.util.BaseFileManager
      com.sun.tools.javac.nio.JavacPathFileManager

All Implemented Interfaces:
    PathFileManager

Implementation of PathFileManager: a JavaFileManager based on the use of java.nio.file.Path.

Just as a Path is somewhat analagous to a File, so too is this JavacPathFileManager analogous to JavacFileManager, as it relates to the support of FileObjects based on File objects (i.e. just RegularFileObject, not ZipFileObject and its variants.)

The default values for the standard locations supported by this file manager are the same as the default values provided by JavacFileManager -- i.e. as determined by the javac.file.Paths class. To override these values, call #setLocation .

To reduce confusion with Path objects, the locations such as "class path", "source path", etc, are generically referred to here as "search paths".

This is NOT part of any supported API. If you write code that depends on this, you do so at your own risk. This code and its internal interfaces are subject to change or deletion without notice.

Field Summary
protected  FileSystem	defaultFileSystem

Fields inherited from com.sun.tools.javac.util.BaseFileManager:
log,  charset,  options,  classLoaderClass,  contentCache

Constructor:

public JavacPathFileManager(Context context, boolean register, Charset charset) { super(charset); if (register) context.put(JavaFileManager.class, this); pathsForLocation = new HashMap< Location, PathsForLocation >(); fileSystems = new HashMap< Path,FileSystem >(); setContext(context); } Create a JavacPathFileManager using a given context, optionally registering it as the JavaFileManager for that context.

Method from com.sun.tools.javac.nio.JavacPathFileManager Summary:
close,   flush,   getClassLoader,   getDefaultFileSystem,   getFileForInput,   getFileForOutput,   getJavaFileForInput,   getJavaFileForOutput,   getJavaFileObjects,   getJavaFileObjectsFromPaths,   getLocation,   getPath,   hasLocation,   inferBinaryName,   isDefaultBootClassPath,   isSameFile,   list,   setContext,   setDefaultFileSystem,   setLocation

Methods from com.sun.tools.javac.util.BaseFileManager:
cache,   decode,   getCachedContent,   getClassLoader,   getDecoder,   getEncodingName,   getKind,   getSource,   handleOption,   isDefaultBootClassPath,   isSupportedOption,   makeByteBuffer,   nullCheck,   nullCheck,   recycleByteBuffer,   setContext

Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait

Method from com.sun.tools.javac.nio.JavacPathFileManager Detail:
public void close() throws IOException { for (FileSystem fs: fileSystems.values()) fs.close(); }
public void flush() throws IOException { contentCache.clear(); }
public ClassLoader getClassLoader(Location location) { nullCheck(location); Iterable< ? extends Path > path = getLocation(location); if (path == null) return null; ListBuffer< URL > lb = new ListBuffer< URL >(); for (Path p: path) { try { lb.append(p.toUri().toURL()); } catch (MalformedURLException e) { throw new AssertionError(e); } } return getClassLoader(lb.toArray(new URL[lb.size()])); }
public FileSystem getDefaultFileSystem() { if (defaultFileSystem == null) defaultFileSystem = FileSystems.getDefault(); return defaultFileSystem; }
public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException { return getFileForInput(location, getRelativePath(packageName, relativeName)); }
public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException { return getFileForOutput(location, getRelativePath(packageName, relativeName), sibling); }
public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException { return getFileForInput(location, getRelativePath(className, kind)); }
public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException { return getFileForOutput(location, getRelativePath(className, kind), sibling); }
public Iterable<JavaFileObject> getJavaFileObjects(Path paths) { return getJavaFileObjectsFromPaths(Arrays.asList(nullCheck(paths))); }
public Iterable<JavaFileObject> getJavaFileObjectsFromPaths(Iterable<Path> paths) { ArrayList< PathFileObject > result; if (paths instanceof Collection< ? >) result = new ArrayList< PathFileObject >(((Collection< ? >)paths).size()); else result = new ArrayList< PathFileObject >(); for (Path p: paths) result.add(PathFileObject.createSimplePathFileObject(this, nullCheck(p))); return result; }
public Iterable<Path> getLocation(Location location) { nullCheck(location); lazyInitSearchPaths(); PathsForLocation path = pathsForLocation.get(location); if (path == null && !pathsForLocation.containsKey(location)) { setDefaultForLocation(location); path = pathsForLocation.get(location); } return path; }
public Path getPath(FileObject fo) { nullCheck(fo); if (!(fo instanceof PathFileObject)) throw new IllegalArgumentException(); return ((PathFileObject) fo).getPath(); }
public boolean hasLocation(Location location) { return (getLocation(location) != null); }
public String inferBinaryName(Location location, JavaFileObject fo) { nullCheck(fo); // Need to match the path semantics of list(location, ...) Iterable< ? extends Path > paths = getLocation(location); if (paths == null) { return null; } if (!(fo instanceof PathFileObject)) throw new IllegalArgumentException(fo.getClass().getName()); return ((PathFileObject) fo).inferBinaryName(paths); }
public boolean isDefaultBootClassPath() { return searchPaths.isDefaultBootClassPath(); }
public boolean isSameFile(FileObject a, FileObject b) { nullCheck(a); nullCheck(b); if (!(a instanceof PathFileObject)) throw new IllegalArgumentException("Not supported: " + a); if (!(b instanceof PathFileObject)) throw new IllegalArgumentException("Not supported: " + b); return ((PathFileObject) a).isSameFile((PathFileObject) b); }
public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException { // validatePackageName(packageName); nullCheck(packageName); nullCheck(kinds); Iterable< ? extends Path > paths = getLocation(location); if (paths == null) return List.nil(); ListBuffer< JavaFileObject > results = new ListBuffer< JavaFileObject >(); for (Path path : paths) list(path, packageName, kinds, recurse, results); return results.toList(); }
protected void setContext(Context context) { super.setContext(context); searchPaths = Paths.instance(context); } Set the context for JavacPathFileManager.
public void setDefaultFileSystem(FileSystem fs) { defaultFileSystem = fs; }
public void setLocation(Location location, Iterable<Path> searchPath) throws IOException { nullCheck(location); lazyInitSearchPaths(); if (searchPath == null) { setDefaultForLocation(location); } else { if (location.isOutputLocation()) checkOutputPath(searchPath); PathsForLocation pl = new PathsForLocation(); for (Path p: searchPath) pl.add(p); // TODO -Xlint:path warn if path not found pathsForLocation.put(location, pl); } }