jdk-sandbox: comparison langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/util/StandardDocFileFactory.java

equal deleted inserted replaced

-:6c644cca3f3f
+:688096b6bcc4
 /*
-* Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2016, 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
 package com.sun.tools.doclets.internal.toolkit.util;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedWriter;
-import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.UnsupportedEncodingException;
 import java.io.Writer;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 *
 * @since 1.8
 */
 class StandardDocFileFactory extends DocFileFactory {
 private final StandardJavaFileManager fileManager;
-private File destDir;
+private Path destDir;
 public StandardDocFileFactory(Configuration configuration) {
 super(configuration);
 fileManager = (StandardJavaFileManager) configuration.getFileManager();
 }
-private File getDestDir() {
+private Path 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);
+Path dir = Paths.get(dirName);
-fileManager.setLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(dir));
+fileManager.setLocationFromPaths(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(dir));
 } catch (IOException e) {
 throw new DocletAbortException(e);
 }
 }
-destDir = fileManager.getLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT).iterator().next();
+destDir = fileManager.getLocationAsPaths(DocumentationTool.Location.DOCUMENTATION_OUTPUT).iterator().next();
 }
 return destDir;
 }
 public DocFile createFileForDirectory(String file) {
-return new StandardDocFile(new File(file));
+return new StandardDocFile(Paths.get(file));
 }
 public DocFile createFileForInput(String file) {
-return new StandardDocFile(new File(file));
+return new StandardDocFile(Paths.get(file));
 }
 public DocFile createFileForOutput(DocPath path) {
 return new StandardDocFile(DocumentationTool.Location.DOCUMENTATION_OUTPUT, path);
 }
 throw new IllegalArgumentException();
 Set<DocFile> files = new LinkedHashSet<>();
 Location l = fileManager.hasLocation(StandardLocation.SOURCE_PATH)
 ? StandardLocation.SOURCE_PATH : StandardLocation.CLASS_PATH;
-for (File f: fileManager.getLocation(l)) {
+for (Path f: fileManager.getLocationAsPaths(l)) {
-if (f.isDirectory()) {
+if (Files.isDirectory(f)) {
-f = new File(f, path.getPath());
+f = f.resolve(path.getPath());
-if (f.exists())
+if (Files.exists(f))
 files.add(new StandardDocFile(f));
 }
 }
 return files;
 }
-private static File newFile(File dir, String path) {
+private static Path newFile(Path dir, String path) {
-return (dir == null) ? new File(path) : new File(dir, path);
+return (dir == null) ? Paths.get(path) : dir.resolve(path);
 }
 class StandardDocFile extends DocFile {
-private File file;
+private Path file;
 /** Create a StandardDocFile for a given file. */
-private StandardDocFile(File file) {
+private StandardDocFile(Path file) {
 super(configuration);
 this.file = file;
 }
 /** Create a StandardDocFile for a given location and relative path. */
 }
 }
 /** Return true if the file can be read. */
 public boolean canRead() {
-return file.canRead();
+return Files.isReadable(file);
 }
 /** Return true if the file can be written. */
 public boolean canWrite() {
-return file.canWrite();
+return Files.isWritable(file);
 }
 /** Return true if the file exists. */
 public boolean exists() {
-return file.exists();
+return Files.exists(file);
 }
 /** Return the base name (last component) of the file name. */
 public String getName() {
-return file.getName();
+return file.getFileName().toString();
 }
 /** Return the file system path for this file. */
 public String getPath() {
-return file.getPath();
+return file.toString();
 }
 /** Return true is file has an absolute path name. */
 public boolean isAbsolute() {
 return file.isAbsolute();
 }
 /** Return true is file identifies a directory. */
 public boolean isDirectory() {
-return file.isDirectory();
+return Files.isDirectory(file);
 }
 /** Return true is file identifies a file. */
 public boolean isFile() {
-return file.isFile();
+return Files.isRegularFile(file);
 }
 /** Return true if this file is the same as another. */
 public boolean isSameFile(DocFile other) {
 if (!(other instanceof StandardDocFile))
 return false;
 try {
-return file.exists()
+return Files.isSameFile(file, ((StandardDocFile) other).file);
-&& file.getCanonicalFile().equals(((StandardDocFile) other).file.getCanonicalFile());
 } catch (IOException e) {
 return false;
 }
 }
 /** If the file is a directory, list its contents. */
-public Iterable<DocFile> list() {
+public Iterable<DocFile> list() throws IOException {
-List<DocFile> files = new ArrayList<>();
+List<DocFile> files = new ArrayList<DocFile>();
-for (File f: file.listFiles()) {
+try (DirectoryStream<Path> ds = Files.newDirectoryStream(file)) {
-files.add(new StandardDocFile(f));
+for (Path f: ds) {
+files.add(new StandardDocFile(f));
+}
 }
 return files;
 }
 /** Create the file as a directory, including any parent directories. */
 public boolean mkdirs() {
-return file.mkdirs();
+try {
+Files.createDirectories(file);
+return true;
+} catch (IOException e) {
+return false;
+}
 }
 /**
 * Derive a new file by resolving a relative path against this file.
 * The new file will inherit the configuration and location of this file
 * If this file has a path set, the new file will have a corresponding
 * new path.
 */
 public DocFile resolve(String p) {
 if (location == null && path == null) {
-return new StandardDocFile(new File(file, p));
+return new StandardDocFile(file.resolve(p));
 } else {
 return new StandardDocFile(location, path.resolve(p));
 }
 }
 /**
 * Resolve a relative file against the given output location.
 * @param locn Currently, only
-* {@link DocumentationTool.Location#DOCUMENTATION_OUTPUT} is supported.
+* {@link DocumentationTool.Location.DOCUMENTATION_OUTPUT} is supported.
 */
 public DocFile resolveAgainst(Location locn) {
 if (locn != DocumentationTool.Location.DOCUMENTATION_OUTPUT)
 throw new IllegalArgumentException();
-return new StandardDocFile(newFile(getDestDir(), file.getPath()));
+return new StandardDocFile(getDestDir().resolve(file));
 }
 /** Return a string to identify the contents of this object,
 * for debugging purposes.
 */
 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder();
-sb.append("StandardDocFile[");
+sb.append("PathDocFile[");
 if (location != null)
 sb.append("locn:").append(location).append(",");
 if (path != null)
 sb.append("path:").append(path.getPath()).append(",");
 sb.append("file:").append(file);
 sb.append("]");
 return sb.toString();
 }
-private JavaFileObject getJavaFileObjectForInput(File file) {
+private JavaFileObject getJavaFileObjectForInput(Path file) {
 return fileManager.getJavaFileObjects(file).iterator().next();
 }
 private FileObject getFileObjectForOutput(DocPath path) throws IOException {
 // break the path into a package-part and the rest, by finding

changeset 36037	688096b6bcc4
parent 25874	83c19f00452c
child 36526	3b41f1c69604