javax.tools.JavaFileManager.Location Java Examples

private Location findModule(String moduleName) throws IOException {
    Location[] locns = {
        StandardLocation.UPGRADE_MODULE_PATH,
        StandardLocation.SYSTEM_MODULES,
        StandardLocation.MODULE_PATH
    };
    for (Location segment: locns) {
        for (Set<Location> set: fileManager.listLocationsForModules(segment)) {
            Location result = null;
            for (Location l: set) {
                String name = fileManager.inferModuleName(l);
                if (name.equals(moduleName)) {
                    if (result == null)
                        result = l;
                    else
                        throw new IOException("multiple definitions found for " + moduleName);
                }
            }
            if (result != null)
                return result;
        }
    }
    return null;
}
 

private File getDestDir() {
    if (destDir == null) {
        if (!configuration.destDirName.isEmpty()
                || !fileManager.hasLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT)) {
            try {
                String dirName = configuration.destDirName.isEmpty() ? "." : configuration.destDirName;
                File dir = new File(dirName);
                fileManager.setLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(dir));
            } catch (IOException e) {
                throw new DocletAbortException(e);
            }
        }

        destDir = fileManager.getLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT).iterator().next();
    }
    return destDir;
}
 

void initHandlers() {
    handlersForLocation = new HashMap<Location, LocationHandler>();
    handlersForOption = new EnumMap<Option, LocationHandler>(Option.class);

    LocationHandler[] handlers = {
        new BootClassPathLocationHandler(),
        new ClassPathLocationHandler(),
        new SimpleLocationHandler(StandardLocation.SOURCE_PATH, Option.SOURCEPATH),
        new SimpleLocationHandler(StandardLocation.ANNOTATION_PROCESSOR_PATH, Option.PROCESSORPATH),
        new OutputLocationHandler((StandardLocation.CLASS_OUTPUT), Option.D),
        new OutputLocationHandler((StandardLocation.SOURCE_OUTPUT), Option.S),
        new OutputLocationHandler((StandardLocation.NATIVE_HEADER_OUTPUT), Option.H)
    };

    for (LocationHandler h: handlers) {
        handlersForLocation.put(h.location, h);
        for (Option o: h.options)
            handlersForOption.put(o, h);
    }
}
 

@SuppressWarnings("unchecked")
private void computeSubpackages() throws ToolException {
    ((List<String>) opts.computeIfAbsent(ToolOption.EXCLUDE, v -> Collections.EMPTY_LIST))
            .stream()
            .map(ModulePackage::new)
            .forEachOrdered((mpkg) -> excludePackages.add(mpkg));

    excludePackages.forEach((p) -> {
        getEntry(p).excluded = true;
    });

    for (ModulePackage modpkg : subPackages) {
        List<Location> locs = getLocation(modpkg);
        for (Location loc : locs) {
            addPackagesFromLocations(loc, modpkg);
        }
    }
}
 

@Override
Iterable<DocFile> list(Location location, DocPath path) {
    if (location != StandardLocation.SOURCE_PATH)
        throw new IllegalArgumentException();

    Set<DocFile> files = new LinkedHashSet<DocFile>();
    if (fileManager.hasLocation(location)) {
        for (Path f: fileManager.getLocation(location)) {
            if (Files.isDirectory(f)) {
                f = f.resolve(path.getPath());
                if (Files.exists(f))
                    files.add(new StandardDocFile(f));
            }
        }
    }
    return files;
}
 

void checkContains(StandardJavaFileManager fm, Location l, FileObject fo, boolean expect) throws IOException {
    boolean found = fm.contains(l, fo);
    if (found) {
        if (expect) {
            out.println("file found, as expected: " + l + " " + fo.getName());
        } else {
            error("file not found: " + l + " " + fo.getName());
        }
    } else {
        if (expect) {
            error("file found unexpectedly: " + l + " " + fo.getName());
        } else {
            out.println("file not found, as expected: " + l + " " + fo.getName());
        }
    }
}
 

private Set<PackageElement> getAllModulePackages(ModuleElement mdle) throws ToolException {
    Set<PackageElement> result = new HashSet<>();
    ModuleSymbol msym = (ModuleSymbol) mdle;
    List<Location> msymlocs = getModuleLocation(locations, msym.name.toString());
    for (Location msymloc : msymlocs) {
        for (JavaFileObject fo : fmList(msymloc, "", sourceKinds, true)) {
            if (fo.getName().endsWith("module-info.java")) {
                continue;
            }
            String binaryName = fm.inferBinaryName(msymloc, fo);
            String pn = getPackageName(binaryName);
            PackageSymbol psym = syms.enterPackage(msym, names.fromString(pn));
            result.add((PackageElement) psym);
        }
    }
    return result;
}
 

private JavaFileObjectSubject checkGeneratedFile(
    Optional<JavaFileObject> generatedFile, Location location, String path) {
  if (!generatedFile.isPresent()) {
    // TODO(b/132162475): Use Facts if it becomes public API.
    ImmutableList.Builder<Fact> facts = ImmutableList.builder();
    facts.add(fact("in location", location.getName()));
    facts.add(simpleFact("it generated:"));
    for (JavaFileObject generated : actual.generatedFiles()) {
      if (generated.toUri().getPath().contains(location.getName())) {
        facts.add(simpleFact("  " + generated.toUri().getPath()));
      }
    }
    failWithoutActual(
        fact("expected to generate file", "/" + path), facts.build().toArray(new Fact[0]));
    return ignoreCheck().about(javaFileObjects()).that(ALREADY_FAILED);
  }
  return check("generatedFile(/%s)", path).about(javaFileObjects()).that(generatedFile.get());
}
 

private File getDestDir() {
    if (destDir == null) {
        if (!configuration.destDirName.isEmpty()
                || !fileManager.hasLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT)) {
            try {
                String dirName = configuration.destDirName.isEmpty() ? "." : configuration.destDirName;
                File dir = new File(dirName);
                fileManager.setLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(dir));
            } catch (IOException e) {
                throw new DocletAbortException(e);
            }
        }

        destDir = fileManager.getLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT).iterator().next();
    }
    return destDir;
}
 

@Override
public JavaFileObject getJavaFileForInput (Location l, final String className, JavaFileObject.Kind kind) {
    String[] namePair = FileObjects.getParentRelativePathAndName (className);
    String ext = kind == JavaFileObject.Kind.CLASS ? FileObjects.SIG : kind.extension.substring(1);   //tzezula: Clearly wrong in compile on save, but "class" is also wrong
    for (ClassPath.Entry entry : this.sourceRoots.entries()) {
        FileObject root = entry.getRoot();
        if (root != null) {
            FileObject parent = root.getFileObject(namePair[0]);
            if (parent != null) {
                FileObject[] children = parent.getChildren();
                for (FileObject child : children) {
                    if (namePair[1].equals(child.getName()) && ext.equalsIgnoreCase(child.getExt()) && (ignoreExcludes || entry.includes(child))) {
                        return FileObjects.sourceFileObject(child, root);
                    }
                }
            }
        }
    }
    return null;
}
 

public FileObject createResource(JavaFileManager.Location location,
                                 CharSequence pkg,
                                 CharSequence relativeName,
                                 Element... originatingElements) throws IOException {
    locationCheck(location);

    String strPkg = pkg.toString();
    if (strPkg.length() > 0)
        checkName(strPkg);

    FileObject fileObject =
        fileManager.getFileForOutput(location, strPkg,
                                     relativeName.toString(), null);
    checkFileReopening(fileObject, true);

    if (fileObject instanceof JavaFileObject)
        return new FilerOutputJavaFileObject(null, (JavaFileObject)fileObject);
    else
        return new FilerOutputFileObject(null, fileObject);
}
 

private void fillIn(PackageSymbol p,
                    Location location,
                    Iterable<JavaFileObject> files)
{
    currentLoc = location;
    for (JavaFileObject fo : files) {
        switch (fo.getKind()) {
        case CLASS:
        case SOURCE: {
            // TODO pass binaryName to includeClassFile
            String binaryName = fileManager.inferBinaryName(currentLoc, fo);
            String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);
            if (SourceVersion.isIdentifier(simpleName) ||
                simpleName.equals("package-info"))
                includeClassFile(p, fo);
            break;
        }
        default:
            extraFileActions(p, fo);
        }
    }
}
 

public FileObject createResource(JavaFileManager.Location location,
                                 CharSequence pkg,
                                 CharSequence relativeName,
                                 Element... originatingElements) throws IOException {
    locationCheck(location);

    String strPkg = pkg.toString();
    if (strPkg.length() > 0)
        checkName(strPkg);

    FileObject fileObject =
        fileManager.getFileForOutput(location, strPkg,
                                     relativeName.toString(), null);
    checkFileReopening(fileObject, true);

    if (fileObject instanceof JavaFileObject)
        return new FilerOutputJavaFileObject(null, (JavaFileObject)fileObject);
    else
        return new FilerOutputFileObject(null, fileObject);
}
 

@Override
Iterable<DocFile> list(Location location, DocPath path) {
    if (location != StandardLocation.SOURCE_PATH)
        throw new IllegalArgumentException();

    Set<DocFile> files = new LinkedHashSet<DocFile>();
    if (fileManager.hasLocation(location)) {
        for (Path f: fileManager.getLocation(location)) {
            if (Files.isDirectory(f)) {
                f = f.resolve(path.getPath());
                if (Files.exists(f))
                    files.add(new StandardDocFile(f));
            }
        }
    }
    return files;
}
 

@Test
public void testBasic(Path base) throws IOException {
    try (StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null)) {
        Location[] locns = {
            StandardLocation.SOURCE_PATH,
            StandardLocation.CLASS_PATH,
            StandardLocation.PLATFORM_CLASS_PATH,
        };
        // set a value
        Path out = Files.createDirectories(base.resolve("out"));
        for (Location locn : locns) {
            checkException("unsupported for location",
                    IllegalArgumentException.class,
                    "location is not an output location or a module-oriented location: " + locn,
                    () -> fm.setLocationForModule(locn, "m", List.of(out)));
        }
    }
}
 

@NonNull
private Collection<File> listDir(
        @NonNull final Location location,
        @NonNull final String dir) {
    final Map<String, Map<File, CachedFileObject>> cache = getCacheLine(location, true);
    Map<File, CachedFileObject> content = cache.get(dir);
    return content == null ? Collections.<File>emptyList() : content.keySet();
}
 

private void locationCheck(JavaFileManager.Location location) {
    if (location instanceof StandardLocation) {
        StandardLocation stdLoc = (StandardLocation) location;
        if (!stdLoc.isOutputLocation())
            throw new IllegalArgumentException("Resource creation not supported in location " +
                                               stdLoc);
    }
}
 

private JavaFileObject createSourceOrClassFile(ModuleSymbol mod, boolean isSourceFile, String name) throws IOException {
    Assert.checkNonNull(mod);

    if (lint) {
        int periodIndex = name.lastIndexOf(".");
        if (periodIndex != -1) {
            String base = name.substring(periodIndex);
            String extn = (isSourceFile ? ".java" : ".class");
            if (base.equals(extn))
                log.warning(Warnings.ProcSuspiciousClassName(name, extn));
        }
    }
    checkNameAndExistence(mod, name, isSourceFile);
    Location loc = (isSourceFile ? SOURCE_OUTPUT : CLASS_OUTPUT);

    if (modules.multiModuleMode) {
        loc = this.fileManager.getLocationForModule(loc, mod.name.toString());
    }
    JavaFileObject.Kind kind = (isSourceFile ?
                                JavaFileObject.Kind.SOURCE :
                                JavaFileObject.Kind.CLASS);

    JavaFileObject fileObject =
        fileManager.getJavaFileForOutput(loc, name, kind, null);
    checkFileReopening(fileObject, true);

    if (lastRound)
        log.warning(Warnings.ProcFileCreateLastRound(name));

    if (isSourceFile)
        aggregateGeneratedSourceNames.add(Pair.of(mod, name));
    else
        aggregateGeneratedClassNames.add(Pair.of(mod, name));
    openTypeNames.add(name);

    return new FilerOutputJavaFileObject(mod, name, fileObject);
}
 

/**
 * Open an output stream for the file.
 * The file must have been created with a location of
 * {@link DocumentationTool.Location#DOCUMENTATION_OUTPUT} and a corresponding relative path.
 */
public OutputStream openOutputStream() throws IOException, UnsupportedEncodingException {
    if (location != DocumentationTool.Location.DOCUMENTATION_OUTPUT)
        throw new IllegalStateException();

    OutputStream out = getFileObjectForOutput(path).openOutputStream();
    return new BufferedOutputStream(out);
}
 

static void test(Iterable<? extends File> path, File file, Location location) {
    Iterator<? extends File> it = path.iterator();
    if (!it.next().equals(file))
        throw new AssertionError(file + " not in " + location);
    if (it.hasNext())
        throw new AssertionError("Unexpected element in "  + location + " : " + it.next());
    System.err.format((Locale)null, "OK: %s: %s%n", location, path);
}
 

private JavaFileObject createSourceOrClassFile(boolean isSourceFile, String name) throws IOException {
    if (lint) {
        int periodIndex = name.lastIndexOf(".");
        if (periodIndex != -1) {
            String base = name.substring(periodIndex);
            String extn = (isSourceFile ? ".java" : ".class");
            if (base.equals(extn))
                log.warning("proc.suspicious.class.name", name, extn);
        }
    }
    checkNameAndExistence(name, isSourceFile);
    Location loc = (isSourceFile ? SOURCE_OUTPUT : CLASS_OUTPUT);
    JavaFileObject.Kind kind = (isSourceFile ?
                                JavaFileObject.Kind.SOURCE :
                                JavaFileObject.Kind.CLASS);

    JavaFileObject fileObject =
        fileManager.getJavaFileForOutput(loc, name, kind, null);
    checkFileReopening(fileObject, true);

    if (lastRound)
        log.warning("proc.file.create.last.round", name);

    if (isSourceFile)
        aggregateGeneratedSourceNames.add(name);
    else
        aggregateGeneratedClassNames.add(name);
    openTypeNames.add(name);

    return new FilerOutputJavaFileObject(name, fileObject);
}
 

/**
 * Create a handler. The location and options provide a way to map
 * from a location or an option to the corresponding handler.
 * @see #initHandlers
 */
protected LocationHandler(Location location, Option... options) {
    this.location = location;
    this.options = options.length == 0 ?
        EnumSet.noneOf(Option.class):
        EnumSet.copyOf(Arrays.asList(options));
}
 

@Test
public void testModulePath(Path base) throws IOException {
    try (StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null)) {
        Path src = base.resolve("src");
        Path src_m = src.resolve("m");
        tb.writeJavaFiles(src_m, "module m { }");

        Location locn = StandardLocation.MODULE_PATH;

        Path modules1 = Files.createDirectories(base.resolve("modules1"));
        new JavacTask(tb)
                .outdir(modules1)
                .options("--module-source-path", src.toString())
                .files(tb.findJavaFiles(src))
                .run();
        fm.setLocationFromPaths(locn, List.of(modules1));

        Location m = fm.getLocationForModule(locn, "m");
        checkEqual("default setting",
                fm.getLocationAsPaths(m), modules1.resolve("m"));

        Path override1 = Files.createDirectories(base.resolve("override1"));
        fm.setLocationForModule(locn, "m", List.of(override1));
        checkEqual("override setting 1",
                fm.getLocationAsPaths(m), override1);

        Path override2 = Files.createDirectories(base.resolve("override2"));
        fm.setLocationFromPaths(m, List.of(override2));
        checkEqual("override setting 2",
                fm.getLocationAsPaths(m), override2);

        Path modules2 = Files.createDirectories(base.resolve("modules2"));
        fm.setLocationFromPaths(locn, List.of(modules2));

        checkEqual("updated setting",
                fm.getLocationAsPaths(m), modules2.resolve("m"));
    }
}
 

/**
 * Resolve a relative file against the given output location.
 * @param locn Currently, only
 * {@link DocumentationTool.Location#DOCUMENTATION_OUTPUT} is supported.
 */
public DocFile resolveAgainst(Location locn) {
    if (locn != DocumentationTool.Location.DOCUMENTATION_OUTPUT)
        throw new IllegalArgumentException();
    return new SimpleDocFile(
            new File(configuration.destDirName, file.getPath()));
}
 

/**
 * Open an output stream for the file.
 * The file must have been created with a location of
 * {@link DocumentationTool.Location#DOCUMENTATION_OUTPUT} and a corresponding relative path.
 */
public OutputStream openOutputStream() throws IOException, UnsupportedEncodingException {
    if (location != DocumentationTool.Location.DOCUMENTATION_OUTPUT)
        throw new IllegalStateException();

    OutputStream out = getFileObjectForOutput(path).openOutputStream();
    return new BufferedOutputStream(out);
}
 

private void locationCheck(JavaFileManager.Location location) {
    if (location instanceof StandardLocation) {
        StandardLocation stdLoc = (StandardLocation) location;
        if (!stdLoc.isOutputLocation())
            throw new IllegalArgumentException("Resource creation not supported in location " +
                                               stdLoc);
    }
}
 

private void locationCheck(JavaFileManager.Location location) {
    if (location instanceof StandardLocation) {
        StandardLocation stdLoc = (StandardLocation) location;
        if (!stdLoc.isOutputLocation())
            throw new IllegalArgumentException("Resource creation not supported in location " +
                                               stdLoc);
    }
}
 

void test(boolean hasLocation, File siblingFile, String relName, String expectedPath)
    throws Exception
{
    StandardJavaFileManager fm;
    if (hasLocation) {
        for (Location location : StandardLocation.values()) {
            fm = tool.getStandardFileManager(null, null, null);
            fm.setLocation(location, Arrays.asList(new File(".")));
            test(fm, location, siblingFile, relName, expectedPath);
        }
    } else {
        fm = tool.getStandardFileManager(null, null, null);
        test(fm, CLASS_OUTPUT, siblingFile, relName, expectedPath);
    }
}
 

public PathDocFileFactory(Configuration configuration) {
    super(configuration);
    fileManager = (PathFileManager) configuration.getFileManager();

    if (!configuration.destDirName.isEmpty()
            || !fileManager.hasLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT)) {
        try {
            String dirName = configuration.destDirName.isEmpty() ? "." : configuration.destDirName;
            Path dir = fileManager.getDefaultFileSystem().getPath(dirName);
            fileManager.setLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(dir));
        } catch (IOException e) {
            throw new DocletAbortException(e);
        }
    }

    destDir = fileManager.getLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT).iterator().next();
}
 

/**
 * Create a handler. The location and options provide a way to map
 * from a location or an option to the corresponding handler.
 * @see #initHandlers
 */
protected LocationHandler(Location location, Option... options) {
    this.location = location;
    this.options = options.length == 0 ?
        EnumSet.noneOf(Option.class):
        EnumSet.copyOf(Arrays.asList(options));
}