src/share/classes/java/nio/file/Path.java
Print this page
*** 23,192 ****
* questions.
*/
package java.nio.file;
! import java.nio.file.attribute.*;
! import java.nio.channels.SeekableByteChannel;
import java.io.IOException;
- import java.io.OutputStream;
import java.net.URI;
import java.util.Iterator;
- import java.util.Set;
/**
! * A file reference that locates a file using a system dependent path. The file
! * is not required to exist.
*
! * <p> On many platforms a <em>path</em> is the means to locate and access files
! * in a file system. A path is hierarchical and composed of a sequence of
! * directory and file name elements separated by a special separator or
! * delimiter.
*
- * <h4>Path operations</h4>
- *
- * <p> A system dependent path represented by this class is conceptually a
- * sequence of name elements and optionally a <em>root component</em>. The name
- * that is <em>farthest</em> from the root of the directory hierarchy is the
- * name of a file or directory. The other elements are directory names. The root
- * component typically identifies a file system hierarchy. A {@code Path} can
- * represent a root, a root and a sequence of names, or simply one or more name
- * elements. It defines the {@link #getName() getName}, {@link #getParent
- * getParent}, {@link #getRoot getRoot}, and {@link #subpath subpath} methods
- * to access the components or a subsequence of its name elements.
- *
* <p> In addition to accessing the components of a path, a {@code Path} also
! * defines {@link #resolve(Path) resolve} and {@link #relativize relativize}
! * operations. Paths can also be {@link #compareTo compared}, and tested
! * against each other using using the {@link #startsWith startsWith} and {@link
! * #endsWith endWith} methods.
*
! * <h4>File operations</h4>
*
! * <p> A {@code Path} is either <em>absolute</em> or <em>relative</em>. An
! * absolute path is complete in that does not need to be combined with another
! * path in order to locate a file. All operations on relative paths are first
! * resolved against a file system's default directory as if by invoking the
! * {@link #toAbsolutePath toAbsolutePath} method.
*
! * <p> In addition to the operations defined by the {@link FileRef} interface,
! * this class defines the following operations:
! *
! * <ul>
! * <li><p> The {@link #newByteChannel newByteChannel} method
! * may be used to open a file and obtain a byte channel for reading or
! * writing. </p></li>
! * <li><p> Files may be {@link #createFile(FileAttribute[]) created}, or
! * directories may be {@link #createDirectory(FileAttribute[]) created}.
! * </p></li>
! * <li><p> The {@link #delete delete} method may be used to delete a file.
! * </p></li>
! * <li><p> The {@link #checkAccess checkAccess} method may be used to check
! * the existence or accessibility of a file. </p></li>
! * <li><p> The {@link #isSameFile isSameFile} method may be used to test if
! * two file references locate the same file. </p></li>
! * <li><p> The {@link #getFileStore getFileStore} method may be used to
! * obtain the {@link FileStore} representing the storage where a file is
! * located. </p></li>
! * <li><p> Directories can be {@link #newDirectoryStream opened} so as to
! * iterate over the entries in the directory. </p></li>
! * <li><p> Files can be {@link #copyTo(Path,CopyOption[]) copied} or
! * {@link #moveTo(Path,CopyOption[]) moved}. </p></li>
! * <li><p> Symbolic links may be {@link #createSymbolicLink created}, or the
! * target of a symbolic link may be {@link #readSymbolicLink read}. </p></li>
! * <li><p> The {@link #toRealPath real} path of an existing file may be
! * obtained. </li></p>
! * </ul>
! *
! * <p> This class implements {@link Watchable} interface so that a directory
! * located by a path can be {@link #register registered} with a {@link WatchService}.
! * and entries in the directory watched.
! *
! * <h4>File attributes</h4>
! *
! * In addition to the {@link #setAttribute setAttribute} and {@link #getAttribute
! * getAttribute} methods, the <a href="attribute/package-summary.html">{@code
! * java.nio.file.attribute}</a> package provides type-safe and efficient access
! * to file attributes or <em>meta-data</em> associated with files. The {@link
! * Attributes Attributes} class defines methods that operate on or return file
! * attributes. For example, the file type, size, timestamps, and other
! * <em>basic</em> meta-data are obtained, in bulk, by invoking the {@link
! * Attributes#readBasicFileAttributes Attributes.readBasicFileAttributes} method:
* <pre>
! * Path file = ...
! * BasicFileAttributes attrs = Attributes.readBasicFileAttributes(file);
* </pre>
*
* <a name="interop"><h4>Interoperability</h4></a>
! *
! * <p> Paths created by file systems associated with the default {@link
* java.nio.file.spi.FileSystemProvider provider} are generally interoperable
* with the {@link java.io.File java.io.File} class. Paths created by other
* providers are unlikely to be interoperable with the abstract path names
! * represented by {@code java.io.File}. The {@link java.io.File#toPath
! * File.toPath} method may be used to obtain a {@code Path} from the abstract
! * path name represented by a {@code java.io.File java.io.File} object. The
! * resulting {@code Path} can be used to operate on the same file as the {@code
! * java.io.File} object.
*
- * <p> Path objects created by file systems associated with the default
- * provider are interoperable with objects created by other file systems created
- * by the same provider. Path objects created by file systems associated with
- * other providers may not be interoperable with other file systems created by
- * the same provider. The reasons for this are provider specific.
- *
* <h4>Concurrency</h4></a>
*
- * <p> Instances of this class are immutable and safe for use by multiple concurrent
- * threads.
- *
* @since 1.7
*/
! public abstract class Path
! implements FileRef, Comparable<Path>, Iterable<Path>, Watchable
{
/**
- * Initializes a new instance of this class.
- */
- protected Path() { }
-
- /**
* Returns the file system that created this object.
*
* @return the file system that created this object
*/
! public abstract FileSystem getFileSystem();
/**
* Tells whether or not this path is absolute.
*
! * <p> An absolute path is complete in that it doesn't need to be
! * combined with other path information in order to locate a file.
*
* @return {@code true} if, and only if, this path is absolute
*/
! public abstract boolean isAbsolute();
/**
* Returns the root component of this path as a {@code Path} object,
* or {@code null} if this path does not have a root component.
*
* @return a path representing the root component of this path,
* or {@code null}
*/
! public abstract Path getRoot();
/**
! * Returns the name of the file or directory denoted by this path. The
! * file name is the <em>farthest</em> element from the root in the directory
! * hierarchy.
*
* @return a path representing the name of the file or directory, or
* {@code null} if this path has zero elements
*/
! public abstract Path getName();
/**
* Returns the <em>parent path</em>, or {@code null} if this path does not
* have a parent.
*
--- 23,140 ----
* questions.
*/
package java.nio.file;
! import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Iterator;
/**
! * An object that may be used to locate a file in a file system. It will
! * typically represent a system dependent file path.
*
! * <p> A {@code Path} represents a path that is hierarchical and composed of a
! * sequence of directory and file name elements separated by a special separator
! * or delimiter. A <em>root component</em>, that identifies a file system
! * hierarchy, may also be present. The name element that is <em>farthest</em>
! * from the root of the directory hierarchy is the name of a file or directory.
! * The other name elements are directory names. A {@code Path} can represent a
! * root, a root and a sequence of names, or simply one or more name elements.
! * A {@code Path} is considered to be an <i>empty path</i> if it consists
! * solely of one name element that is empty. Accessing a file using an
! * <i>empty path</i> is equivalent to accessing the default directory of the
! * file system. {@code Path} defines the {@link #getFileName() getFileName},
! * {@link #getParent getParent}, {@link #getRoot getRoot}, and {@link #subpath
! * subpath} methods to access the path components or a subsequence of its name
! * elements.
*
* <p> In addition to accessing the components of a path, a {@code Path} also
! * defines the {@link #resolve(Path) resolve} and {@link #resolveSibling(Path)
! * resolveSibling} methods to combine paths. The {@link #relativize relativize}
! * method that can be used to construct a relative path between two paths.
! * Paths can be {@link #compareTo compared}, and tested against each other using
! * the {@link #startsWith startsWith} and {@link #endsWith endWith} methods.
*
! * <p> This interface extends {@link Watchable} interface so that a directory
! * located by a path can be {@link #register registered} with a {@link
! * WatchService} and entries in the directory watched. </p>
*
! * <p> <b>WARNING:</b> This interface is only intended to be implemented by
! * those developing custom file system implementations. Methods may be added to
! * this interface in future releases. </p>
*
! * <a name="interop"><h4>Accessing Files</h4></a>
! * <p> Paths may be used with the {@link Files} class to operate on files,
! * directories, and other types of files. For example, suppose we want a {@link
! * java.io.BufferedReader} to read text from a file "{@code access.log}". The
! * file is located in a directory "{@code logs}" relative to the current working
! * directory and is UTF-8 encoded.
* <pre>
! * Path path = FileSystems.getDefault().getPath("logs", "access.log");
! * BufferReader reader = Files.newBufferedReader(path, Charset.forName("UTF-8"));
* </pre>
*
* <a name="interop"><h4>Interoperability</h4></a>
! * <p> Paths associated with the default {@link
* java.nio.file.spi.FileSystemProvider provider} are generally interoperable
* with the {@link java.io.File java.io.File} class. Paths created by other
* providers are unlikely to be interoperable with the abstract path names
! * represented by {@code java.io.File}. The {@link java.io.File#toPath toPath}
! * method may be used to obtain a {@code Path} from the abstract path name
! * represented by a {@code java.io.File} object. The resulting {@code Path} can
! * be used to operate on the same file as the {@code java.io.File} object. In
! * addition, the {@link #toFile toFile} method is useful to construct a {@code
! * File} from the {@code String} representation of a {@code Path}.
*
* <h4>Concurrency</h4></a>
+ * <p> Implementations of this interface are immutable and safe for use by
+ * multiple concurrent threads.
*
* @since 1.7
+ * @see Paths
*/
! public interface Path
! extends Comparable<Path>, Iterable<Path>, Watchable
{
/**
* Returns the file system that created this object.
*
* @return the file system that created this object
*/
! FileSystem getFileSystem();
/**
* Tells whether or not this path is absolute.
*
! * <p> An absolute path is complete in that it doesn't need to be combined
! * with other path information in order to locate a file.
*
* @return {@code true} if, and only if, this path is absolute
*/
! boolean isAbsolute();
/**
* Returns the root component of this path as a {@code Path} object,
* or {@code null} if this path does not have a root component.
*
* @return a path representing the root component of this path,
* or {@code null}
*/
! Path getRoot();
/**
! * Returns the name of the file or directory denoted by this path as a
! * {@code Path} object. The file name is the <em>farthest</em> element from
! * the root in the directory hierarchy.
*
* @return a path representing the name of the file or directory, or
* {@code null} if this path has zero elements
*/
! Path getFileName();
/**
* Returns the <em>parent path</em>, or {@code null} if this path does not
* have a parent.
*
*** 207,228 ****
* subpath(0, getNameCount()-1);
* </pre></blockquote>
*
* @return a path representing the path's parent
*/
! public abstract Path getParent();
/**
* Returns the number of name elements in the path.
*
* @return the number of elements in the path, or {@code 0} if this path
* only represents a root component
*/
! public abstract int getNameCount();
/**
! * Returns a name element of this path.
*
* <p> The {@code index} parameter is the index of the name element to return.
* The element that is <em>closest</em> to the root in the directory hierarchy
* has index {@code 0}. The element that is <em>farthest</em> from the root
* has index {@link #getNameCount count}{@code -1}.
--- 155,176 ----
* subpath(0, getNameCount()-1);
* </pre></blockquote>
*
* @return a path representing the path's parent
*/
! Path getParent();
/**
* Returns the number of name elements in the path.
*
* @return the number of elements in the path, or {@code 0} if this path
* only represents a root component
*/
! int getNameCount();
/**
! * Returns a name element of this path as a {@code Path} object.
*
* <p> The {@code index} parameter is the index of the name element to return.
* The element that is <em>closest</em> to the root in the directory hierarchy
* has index {@code 0}. The element that is <em>farthest</em> from the root
* has index {@link #getNameCount count}{@code -1}.
*** 235,245 ****
* @throws IllegalArgumentException
* if {@code index} is negative, {@code index} is greater than or
* equal to the number of elements, or this path has zero name
* elements
*/
! public abstract Path getName(int index);
/**
* Returns a relative {@code Path} that is a subsequence of the name
* elements of this path.
*
--- 183,193 ----
* @throws IllegalArgumentException
* if {@code index} is negative, {@code index} is greater than or
* equal to the number of elements, or this path has zero name
* elements
*/
! Path getName(int index);
/**
* Returns a relative {@code Path} that is a subsequence of the name
* elements of this path.
*
*** 262,272 ****
* @throws IllegalArgumentException
* if {@code beginIndex} is negative, or greater than or equal to
* the number of elements. If {@code endIndex} is less than or
* equal to {@code beginIndex}, or larger than the number of elements.
*/
! public abstract Path subpath(int beginIndex, int endIndex);
/**
* Tests if this path starts with the given path.
*
* <p> This path <em>starts</em> with the given path if this path's root
--- 210,220 ----
* @throws IllegalArgumentException
* if {@code beginIndex} is negative, or greater than or equal to
* the number of elements. If {@code endIndex} is less than or
* equal to {@code beginIndex}, or larger than the number of elements.
*/
! Path subpath(int beginIndex, int endIndex);
/**
* Tests if this path starts with the given path.
*
* <p> This path <em>starts</em> with the given path if this path's root
*** 284,296 ****
* the given path
*
* @return {@code true} if this path starts with the given path; otherwise
* {@code false}
*/
! public abstract boolean startsWith(Path other);
/**
* Tests if this path ends with the given path.
*
* <p> If the given path has <em>N</em> elements, and no root component,
* and this path has <em>N</em> or more elements, then this path ends with
* the given path if the last <em>N</em> elements of each path, starting at
--- 232,262 ----
* the given path
*
* @return {@code true} if this path starts with the given path; otherwise
* {@code false}
*/
! boolean startsWith(Path other);
/**
+ * Tests if this path starts with a {@code Path}, constructed by converting
+ * the given path string, in exactly the manner specified by the {@link
+ * #startsWith(Path) startsWith(Path)} method. On UNIX for example, the path
+ * "{@code foo/bar}" starts with "{@code foo}" and "{@code foo/bar}". It
+ * does not start with "{@code f}" or "{@code fo}".
+ *
+ * @param other
+ * the given path string
+ *
+ * @return {@code true} if this path starts with the given path; otherwise
+ * {@code false}
+ *
+ * @throws InvalidPathException
+ * If the path string cannot be converted to a Path.
+ */
+ boolean startsWith(String other);
+
+ /**
* Tests if this path ends with the given path.
*
* <p> If the given path has <em>N</em> elements, and no root component,
* and this path has <em>N</em> or more elements, then this path ends with
* the given path if the last <em>N</em> elements of each path, starting at
*** 308,320 ****
* the given path
*
* @return {@code true} if this path ends with the given path; otherwise
* {@code false}
*/
! public abstract boolean endsWith(Path other);
/**
* Returns a path that is this path with redundant name elements eliminated.
*
* <p> The precise definition of this method is implementation dependent but
* in general it derives from this path, a path that does not contain
* <em>redundant</em> name elements. In many file systems, the "{@code .}"
--- 274,304 ----
* the given path
*
* @return {@code true} if this path ends with the given path; otherwise
* {@code false}
*/
! boolean endsWith(Path other);
/**
+ * Tests if this path ends with a {@code Path}, constructed by converting
+ * the given path string, in exactly the manner specified by the {@link
+ * #endsWith(Path) endsWith(Path)} method. On UNIX for example, the path
+ * "{@code foo/bar}" ends with "{@code foo/bar}" and "{@code bar}". It does
+ * not end with "{@code r}" or "{@code /bar}".
+ *
+ * @param other
+ * the given path string
+ *
+ * @return {@code true} if this path starts with the given path; otherwise
+ * {@code false}
+ *
+ * @throws InvalidPathException
+ * If the path string cannot be converted to a Path.
+ */
+ boolean endsWith(String other);
+
+ /**
* Returns a path that is this path with redundant name elements eliminated.
*
* <p> The precise definition of this method is implementation dependent but
* in general it derives from this path, a path that does not contain
* <em>redundant</em> name elements. In many file systems, the "{@code .}"
*** 328,389 ****
* <p> This method does not access the file system; the path may not locate
* a file that exists. Eliminating "{@code ..}" and a preceding name from a
* path may result in the path that locates a different file than the original
* path. This can arise when the preceding name is a symbolic link.
*
! * @return the resulting path, or this path if it does not contain
! * redundant name elements, or {@code null} if this path does not
! * have a root component and all name elements are redundant
*
* @see #getParent
* @see #toRealPath
*/
! public abstract Path normalize();
// -- resolution and relativization --
/**
* Resolve the given path against this path.
*
* <p> If the {@code other} parameter is an {@link #isAbsolute() absolute}
* path then this method trivially returns {@code other}. If {@code other}
! * is {@code null} then this path is returned. Otherwise this method
! * considers this path to be a directory and resolves the given path
! * against this path. In the simplest case, the given path does not have
! * a {@link #getRoot root} component, in which case this method <em>joins</em>
! * the given path to this path and returns a resulting path that {@link
! * #endsWith ends} with the given path. Where the given path has a root
! * component then resolution is highly implementation dependent and therefore
! * unspecified.
*
* @param other
! * the path to resolve against this path; can be {@code null}
*
* @return the resulting path
*
* @see #relativize
*/
! public abstract Path resolve(Path other);
/**
* Converts a given path string to a {@code Path} and resolves it against
* this {@code Path} in exactly the manner specified by the {@link
! * #resolve(Path) resolve} method.
*
* @param other
* the path string to resolve against this path
*
* @return the resulting path
*
* @throws InvalidPathException
! * If the path string cannot be converted to a Path.
*
* @see FileSystem#getPath
*/
! public abstract Path resolve(String other);
/**
* Constructs a relative path between this path and a given path.
*
* <p> Relativization is the inverse of {@link #resolve(Path) resolution}.
* This method attempts to construct a {@link #isAbsolute relative} path
* that when {@link #resolve(Path) resolved} against this path, yields a
--- 312,414 ----
* <p> This method does not access the file system; the path may not locate
* a file that exists. Eliminating "{@code ..}" and a preceding name from a
* path may result in the path that locates a different file than the original
* path. This can arise when the preceding name is a symbolic link.
*
! * @return the resulting path or this path if it does not contain
! * redundant name elements; an empty path is returned if this path
! * does have a root component and all name elements are redundant
*
* @see #getParent
* @see #toRealPath
*/
! Path normalize();
// -- resolution and relativization --
/**
* Resolve the given path against this path.
*
* <p> If the {@code other} parameter is an {@link #isAbsolute() absolute}
* path then this method trivially returns {@code other}. If {@code other}
! * is an <i>empty path</i> then this method trivially returns this path.
! * Otherwise this method considers this path to be a directory and resolves
! * the given path against this path. In the simplest case, the given path
! * does not have a {@link #getRoot root} component, in which case this method
! * <em>joins</em> the given path to this path and returns a resulting path
! * that {@link #endsWith ends} with the given path. Where the given path has
! * a root component then resolution is highly implementation dependent and
! * therefore unspecified.
*
* @param other
! * the path to resolve against this path
*
* @return the resulting path
*
* @see #relativize
*/
! Path resolve(Path other);
/**
* Converts a given path string to a {@code Path} and resolves it against
* this {@code Path} in exactly the manner specified by the {@link
! * #resolve(Path) resolve} method. For example, suppose that the name
! * separator is "{@code /}" and a path represents "{@code foo/bar}", then
! * invoking this method with the path string "{@code gus}" will result in
! * the {@code Path} "{@code foo/bar/gus}".
*
* @param other
* the path string to resolve against this path
*
* @return the resulting path
*
* @throws InvalidPathException
! * if the path string cannot be converted to a Path.
*
* @see FileSystem#getPath
*/
! Path resolve(String other);
/**
+ * Resolves the given path against this path's {@link #getParent parent}
+ * path. This is useful where a file name needs to be <i>replaced</i> with
+ * another file name. For example, suppose that the name separator is
+ * "{@code /}" and a path represents "{@code dir1/dir2/foo}", then invoking
+ * this method with the {@code Path} "{@code bar}" will result in the {@code
+ * Path} "{@code dir1/dir2/bar}". If this path does not have a parent path,
+ * or {@code other} is {@link #isAbsolute() absolute}, then this method
+ * returns {@code other}. If {@code other} is an empty path then this method
+ * returns this path's parent, or where this path doesn't have a parent, the
+ * empty path.
+ *
+ * @param other
+ * the path to resolve against this path's parent
+ *
+ * @return the resulting path
+ *
+ * @see #resolve(Path)
+ */
+ Path resolveSibling(Path other);
+
+ /**
+ * Converts a given path string to a {@code Path} and resolves it against
+ * this path's {@link #getParent parent} path in exactly the manner
+ * specified by the {@link #resolveSibling(Path) resolveSibling} method.
+ *
+ * @param other
+ * the path string to resolve against this path's parent
+ *
+ * @return the resulting path
+ *
+ * @throws InvalidPathException
+ * if the path string cannot be converted to a Path.
+ *
+ * @see FileSystem#getPath
+ */
+ Path resolveSibling(String other);
+
+ /**
* Constructs a relative path between this path and a given path.
*
* <p> Relativization is the inverse of {@link #resolve(Path) resolution}.
* This method attempts to construct a {@link #isAbsolute relative} path
* that when {@link #resolve(Path) resolved} against this path, yields a
*** 393,602 ****
* path and the given path do not have a {@link #getRoot root} component,
* then a relative path can be constructed. A relative path cannot be
* constructed if only one of the paths have a root component. Where both
* paths have a root component then it is implementation dependent if a
* relative path can be constructed. If this path and the given path are
! * {@link #equals equal} then {@code null} is returned.
*
! * <p> For any two paths <i>p</i> and <i>q</i>, where <i>q</i> does not have
! * a root component,
* <blockquote>
* <i>p</i><tt>.relativize(</tt><i>p</i><tt>.resolve(</tt><i>q</i><tt>)).equals(</tt><i>q</i><tt>)</tt>
* </blockquote>
*
* <p> When symbolic links are supported, then whether the resulting path,
* when resolved against this path, yields a path that can be used to locate
! * the {@link #isSameFile same} file as {@code other} is implementation
* dependent. For example, if this path is {@code "/a/b"} and the given
* path is {@code "/a/x"} then the resulting relative path may be {@code
* "../x"}. If {@code "b"} is a symbolic link then is implementation
* dependent if {@code "a/b/../x"} would locate the same file as {@code "/a/x"}.
*
* @param other
* the path to relativize against this path
*
! * @return the resulting relative path, or {@code null} if both paths are
* equal
*
* @throws IllegalArgumentException
* if {@code other} is not a {@code Path} that can be relativized
* against this path
*/
! public abstract Path relativize(Path other);
- // -- file operations --
-
/**
- * Deletes the file located by this path.
- *
- * <p> An implementation may require to examine the file to determine if the
- * file is a directory. Consequently this method may not be atomic with respect
- * to other file system operations. If the file is a symbolic link then the
- * symbolic link itself, not the final target of the link, is deleted.
- *
- * <p> If the file is a directory then the directory must be empty. In some
- * implementations a directory has entries for special files or links that
- * are created when the directory is created. In such implementations a
- * directory is considered empty when only the special entries exist.
- *
- * <p> On some operating systems it may not be possible to remove a file when
- * it is open and in use by this Java virtual machine or other programs.
- *
- * @throws NoSuchFileException
- * if the file does not exist <i>(optional specific exception)</i>
- * @throws DirectoryNotEmptyException
- * if the file is a directory and could not otherwise be deleted
- * because the directory is not empty <i>(optional specific
- * exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkDelete(String)} method
- * is invoked to check delete access to the file
- */
- public abstract void delete() throws IOException;
-
- /**
- * Deletes the file located by this path, if it exists.
- *
- * <p> As with the {@link #delete delete()} method, an implementation may
- * need to examine the file to determine if the file is a directory.
- * Consequently this method may not be atomic with respect to other file
- * system operations. If the file is a symbolic link, then the symbolic
- * link itself, not the final target of the link, is deleted.
- *
- * <p> If the file is a directory then the directory must be empty. In some
- * implementations a directory has entries for special files or links that
- * are created when the directory is created. In such implementations a
- * directory is considered empty when only the special entries exist.
- *
- * <p> On some operating systems it may not be possible to remove a file when
- * it is open and in use by this Java virtual machine or other programs.
- *
- * @throws DirectoryNotEmptyException
- * if the file is a directory and could not otherwise be deleted
- * because the directory is not empty <i>(optional specific
- * exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkDelete(String)} method
- * is invoked to check delete access to the file.
- */
- public abstract void deleteIfExists() throws IOException;
-
- /**
- * Creates a symbolic link to a target <i>(optional operation)</i>.
- *
- * <p> The {@code target} parameter is the target of the link. It may be an
- * {@link Path#isAbsolute absolute} or relative path and may not exist. When
- * the target is a relative path then file system operations on the resulting
- * link are relative to the path of the link.
- *
- * <p> The {@code attrs} parameter is an optional array of {@link FileAttribute
- * attributes} to set atomically when creating the link. Each attribute is
- * identified by its {@link FileAttribute#name name}. If more than one attribute
- * of the same name is included in the array then all but the last occurrence
- * is ignored.
- *
- * <p> Where symbolic links are supported, but the underlying {@link FileStore}
- * does not support symbolic links, then this may fail with an {@link
- * IOException}. Additionally, some operating systems may require that the
- * Java virtual machine be started with implementation specific privileges to
- * create symbolic links, in which case this method may throw {@code IOException}.
- *
- * @param target
- * the target of the symbolic link
- * @param attrs
- * the array of attributes to set atomically when creating the
- * symbolic link
- *
- * @return this path
- *
- * @throws UnsupportedOperationException
- * if the implementation does not support symbolic links or the
- * array contains an attribute that cannot be set atomically when
- * creating the symbolic link
- * @throws FileAlreadyExistsException
- * if a file with the name already exists <i>(optional specific
- * exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager
- * is installed, it denies {@link LinkPermission}<tt>("symbolic")</tt>
- * or its {@link SecurityManager#checkWrite(String) checkWrite}
- * method denies write access to the path of the symbolic link.
- */
- public abstract Path createSymbolicLink(Path target, FileAttribute<?>... attrs)
- throws IOException;
-
- /**
- * Creates a new link (directory entry) for an existing file <i>(optional
- * operation)</i>.
- *
- * <p> This path locates the directory entry to create. The {@code existing}
- * parameter is the path to an existing file. This method creates a new
- * directory entry for the file so that it can be accessed using this path.
- * On some file systems this is known as creating a "hard link". Whether the
- * file attributes are maintained for the file or for each directory entry
- * is file system specific and therefore not specified. Typically, a file
- * system requires that all links (directory entries) for a file be on the
- * same file system. Furthermore, on some platforms, the Java virtual machine
- * may require to be started with implementation specific privileges to
- * create hard links or to create links to directories.
- *
- * @param existing
- * a reference to an existing file
- *
- * @return this path
- *
- * @throws UnsupportedOperationException
- * if the implementation does not support adding an existing file
- * to a directory
- * @throws FileAlreadyExistsException
- * if the entry could not otherwise be created because a file of
- * that name already exists <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager
- * is installed, it denies {@link LinkPermission}<tt>("hard")</tt>
- * or its {@link SecurityManager#checkWrite(String) checkWrite}
- * method denies write access to both this path and the path of the
- * existing file.
- */
- public abstract Path createLink(Path existing) throws IOException;
-
- /**
- * Reads the target of a symbolic link <i>(optional operation)</i>.
- *
- * <p> If the file system supports <a href="package-summary.html#links">symbolic
- * links</a> then this method is used to read the target of the link, failing
- * if the file is not a symbolic link. The target of the link need not exist.
- * The returned {@code Path} object will be associated with the same file
- * system as this {@code Path}.
- *
- * @return a {@code Path} object representing the target of the link
- *
- * @throws UnsupportedOperationException
- * if the implementation does not support symbolic links
- * @throws NotLinkException
- * if the target could otherwise not be read because the file
- * is not a symbolic link <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager
- * is installed, it checks that {@code FilePermission} has been
- * granted with the "{@code readlink}" action to read the link.
- */
- public abstract Path readSymbolicLink() throws IOException;
-
- /**
* Returns a URI to represent this path.
*
* <p> This method constructs a hierarchical {@link URI} that is absolute
* with a non-empty path component. Its {@link URI#getScheme() scheme} is
* equal to the URI scheme that identifies the provider. The exact form of
--- 418,456 ----
* path and the given path do not have a {@link #getRoot root} component,
* then a relative path can be constructed. A relative path cannot be
* constructed if only one of the paths have a root component. Where both
* paths have a root component then it is implementation dependent if a
* relative path can be constructed. If this path and the given path are
! * {@link #equals equal} then an <i>empty path</i> is returned.
*
! * <p> For any two {@link #normalize normalized} paths <i>p</i> and
! * <i>q</i>, where <i>q</i> does not have a root component,
* <blockquote>
* <i>p</i><tt>.relativize(</tt><i>p</i><tt>.resolve(</tt><i>q</i><tt>)).equals(</tt><i>q</i><tt>)</tt>
* </blockquote>
*
* <p> When symbolic links are supported, then whether the resulting path,
* when resolved against this path, yields a path that can be used to locate
! * the {@link Files#isSameFile same} file as {@code other} is implementation
* dependent. For example, if this path is {@code "/a/b"} and the given
* path is {@code "/a/x"} then the resulting relative path may be {@code
* "../x"}. If {@code "b"} is a symbolic link then is implementation
* dependent if {@code "a/b/../x"} would locate the same file as {@code "/a/x"}.
*
* @param other
* the path to relativize against this path
*
! * @return the resulting relative path, or an empty path if both paths are
* equal
*
* @throws IllegalArgumentException
* if {@code other} is not a {@code Path} that can be relativized
* against this path
*/
! Path relativize(Path other);
/**
* Returns a URI to represent this path.
*
* <p> This method constructs a hierarchical {@link URI} that is absolute
* with a non-empty path component. Its {@link URI#getScheme() scheme} is
* equal to the URI scheme that identifies the provider. The exact form of
*** 645,655 ****
* @throws SecurityException
* In the case of the default provider, and a security manager
* is installed, the {@link #toAbsolutePath toAbsolutePath} method
* throws a security exception.
*/
! public abstract URI toUri();
/**
* Returns a {@code Path} object representing the absolute path of this
* path.
*
--- 499,509 ----
* @throws SecurityException
* In the case of the default provider, and a security manager
* is installed, the {@link #toAbsolutePath toAbsolutePath} method
* throws a security exception.
*/
! URI toUri();
/**
* Returns a {@code Path} object representing the absolute path of this
* path.
*
*** 668,685 ****
* is installed, and this path is not absolute, then the security
* manager's {@link SecurityManager#checkPropertyAccess(String)
* checkPropertyAccess} method is invoked to check access to the
* system property {@code user.dir}
*/
! public abstract Path toAbsolutePath();
/**
* Returns the <em>real</em> path of an existing file.
*
* <p> The precise definition of this method is implementation dependent but
* in general it derives from this path, an {@link #isAbsolute absolute}
! * path that locates the {@link #isSameFile same} file as this path, but
* with name elements that represent the actual name of the directories
* and the file. For example, where filename comparisons on a file system
* are case insensitive then the name elements represent the names in their
* actual case. Additionally, the resulting path has redundant name
* elements removed.
--- 522,539 ----
* is installed, and this path is not absolute, then the security
* manager's {@link SecurityManager#checkPropertyAccess(String)
* checkPropertyAccess} method is invoked to check access to the
* system property {@code user.dir}
*/
! Path toAbsolutePath();
/**
* Returns the <em>real</em> path of an existing file.
*
* <p> The precise definition of this method is implementation dependent but
* in general it derives from this path, an {@link #isAbsolute absolute}
! * path that locates the {@link Files#isSameFile same} file as this path, but
* with name elements that represent the actual name of the directories
* and the file. For example, where filename comparisons on a file system
* are case insensitive then the name elements represent the names in their
* actual case. Additionally, the resulting path has redundant name
* elements removed.
*** 711,1480 ****
* method is invoked to check read access to the file, and where
* this path is not absolute, its {@link SecurityManager#checkPropertyAccess(String)
* checkPropertyAccess} method is invoked to check access to the
* system property {@code user.dir}
*/
! public abstract Path toRealPath(boolean resolveLinks) throws IOException;
/**
! * Copy the file located by this path to a target location.
*
! * <p> This method copies the file located by this {@code Path} to the
! * target location with the {@code options} parameter specifying how the
! * copy is performed. By default, the copy fails if the target file already
! * exists, except if the source and target are the {@link #isSameFile same}
! * file, in which case this method has no effect. File attributes are not
! * required to be copied to the target file. If symbolic links are supported,
! * and the file is a symbolic link, then the final target of the link is copied.
! * If the file is a directory then it creates an empty directory in the target
! * location (entries in the directory are not copied). This method can be
! * used with the {@link Files#walkFileTree Files.walkFileTree} utility
! * method to copy a directory and all entries in the directory, or an entire
! * <i>file-tree</i> where required.
*
! * <p> The {@code options} parameter is an array of options and may contain
! * any of the following:
*
- * <table border=1 cellpadding=5 summary="">
- * <tr> <th>Option</th> <th>Description</th> </tr>
- * <tr>
- * <td> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </td>
- * <td> If the target file exists, then the target file is replaced if it
- * is not a non-empty directory. If the target file exists and is a
- * symbolic link, then the symbolic link itself, not the target of
- * the link, is replaced. </td>
- * </tr>
- * <tr>
- * <td> {@link StandardCopyOption#COPY_ATTRIBUTES COPY_ATTRIBUTES} </td>
- * <td> Attempts to copy the file attributes associated with this file to
- * the target file. The exact file attributes that are copied is platform
- * and file system dependent and therefore unspecified. Minimally, the
- * {@link BasicFileAttributes#lastModifiedTime last-modified-time} is
- * copied to the target file if supported by both the source and target
- * file store. Copying of file timestamps may result in precision
- * loss. </td>
- * </tr>
- * <tr>
- * <td> {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} </td>
- * <td> Symbolic links are not followed. If the file, located by this path,
- * is a symbolic link, then the symbolic link itself, not the target of
- * the link, is copied. It is implementation specific if file attributes
- * can be copied to the new link. In other words, the {@code
- * COPY_ATTRIBUTES} option may be ignored when copying a symbolic link. </td>
- * </tr>
- * </table>
- *
- * <p> An implementation of this interface may support additional
- * implementation specific options.
- *
- * <p> Copying a file is not an atomic operation. If an {@link IOException}
- * is thrown then it possible that the target file is incomplete or some of
- * its file attributes have not been copied from the source file. When the
- * {@code REPLACE_EXISTING} option is specified and the target file exists,
- * then the target file is replaced. The check for the existence of the file
- * and the creation of the new file may not be atomic with respect to other
- * file system activities.
- *
- * @param target
- * the target location
- * @param options
- * options specifying how the copy should be done
- *
- * @return the target
- *
* @throws UnsupportedOperationException
! * if the array contains a copy option that is not supported
! * @throws FileAlreadyExistsException
! * if the target file exists and cannot be replaced because the
! * {@code REPLACE_EXISTING} option is not specified, or the target
! * file is a non-empty directory <i>(optional specific exception)</i>
! * @throws IOException
! * if an I/O error occurs
! * @throws SecurityException
! * In the case of the default provider, and a security manager is
! * installed, the {@link SecurityManager#checkRead(String) checkRead}
! * method is invoked to check read access to the source file, the
! * {@link SecurityManager#checkWrite(String) checkWrite} is invoked
! * to check write access to the target file. If a symbolic link is
! * copied the security manager is invoked to check {@link
! * LinkPermission}{@code ("symbolic")}.
*/
! public abstract Path copyTo(Path target, CopyOption... options)
! throws IOException;
- /**
- * Move or rename the file located by this path to a target location.
- *
- * <p> By default, this method attempts to move the file to the target
- * location, failing if the target file exists except if the source and
- * target are the {@link #isSameFile same} file, in which case this method
- * has no effect. If the file is a symbolic link then the symbolic link
- * itself, not the target of the link, is moved. This method may be
- * invoked to move an empty directory. In some implementations a directory
- * has entries for special files or links that are created when the
- * directory is created. In such implementations a directory is considered
- * empty when only the special entries exist. When invoked to move a
- * directory that is not empty then the directory is moved if it does not
- * require moving the entries in the directory. For example, renaming a
- * directory on the same {@link FileStore} will usually not require moving
- * the entries in the directory. When moving a directory requires that its
- * entries be moved then this method fails (by throwing an {@code
- * IOException}). To move a <i>file tree</i> may involve copying rather
- * than moving directories and this can be done using the {@link
- * #copyTo copyTo} method in conjunction with the {@link
- * Files#walkFileTree Files.walkFileTree} utility method.
- *
- * <p> The {@code options} parameter is an array of options and may contain
- * any of the following:
- *
- * <table border=1 cellpadding=5 summary="">
- * <tr> <th>Option</th> <th>Description</th> </tr>
- * <tr>
- * <td> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </td>
- * <td> If the target file exists, then the target file is replaced if it
- * is not a non-empty directory. If the target file exists and is a
- * symbolic link, then the symbolic link itself, not the target of
- * the link, is replaced. </td>
- * </tr>
- * <tr>
- * <td> {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} </td>
- * <td> The move is performed as an atomic file system operation and all
- * other options are ignored. If the target file exists then it is
- * implementation specific if the existing file is replaced or this method
- * fails by throwing an {@link IOException}. If the move cannot be
- * performed as an atomic file system operation then {@link
- * AtomicMoveNotSupportedException} is thrown. This can arise, for
- * example, when the target location is on a different {@code FileStore}
- * and would require that the file be copied, or target location is
- * associated with a different provider to this object. </td>
- * </table>
- *
- * <p> An implementation of this interface may support additional
- * implementation specific options.
- *
- * <p> Where the move requires that the file be copied then the {@link
- * BasicFileAttributes#lastModifiedTime last-modified-time} is copied to the
- * new file. An implementation may also attempt to copy other file
- * attributes but is not required to fail if the file attributes cannot be
- * copied. When the move is performed as a non-atomic operation, and a {@code
- * IOException} is thrown, then the state of the files is not defined. The
- * original file and the target file may both exist, the target file may be
- * incomplete or some of its file attributes may not been copied from the
- * original file.
- *
- * @param target
- * the target location
- * @param options
- * options specifying how the move should be done
- *
- * @return the target
- *
- * @throws UnsupportedOperationException
- * if the array contains a copy option that is not supported
- * @throws FileAlreadyExistsException
- * if the target file exists and cannot be replaced because the
- * {@code REPLACE_EXISTING} option is not specified, or the target
- * file is a non-empty directory
- * @throws AtomicMoveNotSupportedException
- * if the options array contains the {@code ATOMIC_MOVE} option but
- * the file cannot be moved as an atomic file system operation.
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkWrite(String) checkWrite}
- * method is invoked to check write access to both the source and
- * target file.
- */
- public abstract Path moveTo(Path target, CopyOption... options)
- throws IOException;
-
- /**
- * Opens the directory referenced by this object, returning a {@code
- * DirectoryStream} to iterate over all entries in the directory. The
- * elements returned by the directory stream's {@link DirectoryStream#iterator
- * iterator} are of type {@code Path}, each one representing an entry in the
- * directory. The {@code Path} objects are obtained as if by {@link
- * #resolve(Path) resolving} the name of the directory entry against this
- * path.
- *
- * <p> The directory stream's {@code close} method should be invoked after
- * iteration is completed so as to free any resources held for the open
- * directory.
- *
- * <p> When an implementation supports operations on entries in the
- * directory that execute in a race-free manner then the returned directory
- * stream is a {@link SecureDirectoryStream}.
- *
- * @return a new and open {@code DirectoryStream} object
- *
- * @throws NotDirectoryException
- * if the file could not otherwise be opened because it is not
- * a directory <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the directory.
- */
- public abstract DirectoryStream<Path> newDirectoryStream()
- throws IOException;
-
- /**
- * Opens the directory referenced by this object, returning a {@code
- * DirectoryStream} to iterate over the entries in the directory. The
- * elements returned by the directory stream's {@link DirectoryStream#iterator
- * iterator} are of type {@code Path}, each one representing an entry in the
- * directory. The {@code Path} objects are obtained as if by {@link
- * #resolve(Path) resolving} the name of the directory entry against this
- * path. The entries returned by the iterator are filtered by matching the
- * {@code String} representation of their file names against the given
- * <em>globbing</em> pattern.
- *
- * <p> For example, suppose we want to iterate over the files ending with
- * ".java" in a directory:
- * <pre>
- * Path dir = ...
- * DirectoryStream<Path> stream = dir.newDirectoryStream("*.java");
- * </pre>
- *
- * <p> The globbing pattern is specified by the {@link
- * FileSystem#getPathMatcher getPathMatcher} method.
- *
- * <p> The directory stream's {@code close} method should be invoked after
- * iteration is completed so as to free any resources held for the open
- * directory.
- *
- * <p> When an implementation supports operations on entries in the
- * directory that execute in a race-free manner then the returned directory
- * stream is a {@link SecureDirectoryStream}.
- *
- * @param glob
- * the glob pattern
- *
- * @return a new and open {@code DirectoryStream} object
- *
- * @throws java.util.regex.PatternSyntaxException
- * if the pattern is invalid
- * @throws NotDirectoryException
- * if the file could not otherwise be opened because it is not
- * a directory <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the directory.
- */
- public abstract DirectoryStream<Path> newDirectoryStream(String glob)
- throws IOException;
-
- /**
- * Opens the directory referenced by this object, returning a {@code
- * DirectoryStream} to iterate over the entries in the directory. The
- * elements returned by the directory stream's {@link DirectoryStream#iterator
- * iterator} are of type {@code Path}, each one representing an entry in the
- * directory. The {@code Path} objects are obtained as if by {@link
- * #resolve(Path) resolving} the name of the directory entry against this
- * path. The entries returned by the iterator are filtered by the given
- * {@link DirectoryStream.Filter filter}.
- *
- * <p> The directory stream's {@code close} method should be invoked after
- * iteration is completed so as to free any resources held for the open
- * directory.
- *
- * <p> Where the filter terminates due to an uncaught error or runtime
- * exception then it is propagated to the {@link Iterator#hasNext()
- * hasNext} or {@link Iterator#next() next} method. Where an {@code
- * IOException} is thrown, it results in the {@code hasNext} or {@code
- * next} method throwing a {@link DirectoryIteratorException} with the
- * {@code IOException} as the cause.
- *
- * <p> When an implementation supports operations on entries in the
- * directory that execute in a race-free manner then the returned directory
- * stream is a {@link SecureDirectoryStream}.
- *
- * <p> <b>Usage Example:</b>
- * Suppose we want to iterate over the files in a directory that are
- * larger than 8K.
- * <pre>
- * DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {
- * public boolean accept(Path file) throws IOException {
- * long size = Attributes.readBasicFileAttributes(file).size();
- * return (size > 8192L);
- * }
- * };
- * Path dir = ...
- * DirectoryStream<Path> stream = dir.newDirectoryStream(filter);
- * </pre>
- * @param filter
- * the directory stream filter
- *
- * @return a new and open {@code DirectoryStream} object
- *
- * @throws NotDirectoryException
- * if the file could not otherwise be opened because it is not
- * a directory <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the directory.
- */
- public abstract DirectoryStream<Path> newDirectoryStream(DirectoryStream.Filter<? super Path> filter)
- throws IOException;
-
- /**
- * Creates a new and empty file, failing if the file already exists.
- *
- * <p> This {@code Path} locates the file to create. The check for the
- * existence of the file and the creation of the new file if it does not
- * exist are a single operation that is atomic with respect to all other
- * filesystem activities that might affect the directory.
- *
- * <p> The {@code attrs} parameter is an optional array of {@link FileAttribute
- * file-attributes} to set atomically when creating the file. Each attribute
- * is identified by its {@link FileAttribute#name name}. If more than one
- * attribute of the same name is included in the array then all but the last
- * occurrence is ignored.
- *
- * @param attrs
- * an optional list of file attributes to set atomically when
- * creating the file
- *
- * @return this path
- *
- * @throws UnsupportedOperationException
- * if the array contains an attribute that cannot be set atomically
- * when creating the file
- * @throws FileAlreadyExistsException
- * if a file of that name already exists
- * <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkWrite(String) checkWrite}
- * method is invoked to check write access to the new file.
- */
- public abstract Path createFile(FileAttribute<?>... attrs) throws IOException;
-
- /**
- * Creates a new directory.
- *
- * <p> This {@code Path} locates the directory to create. The check for the
- * existence of the file and the creation of the directory if it does not
- * exist are a single operation that is atomic with respect to all other
- * filesystem activities that might affect the directory.
- *
- * <p> The {@code attrs} parameter is an optional array of {@link FileAttribute
- * file-attributes} to set atomically when creating the directory. Each
- * file attribute is identified by its {@link FileAttribute#name name}. If
- * more than one attribute of the same name is included in the array then all
- * but the last occurrence is ignored.
- *
- * @param attrs
- * an optional list of file attributes to set atomically when
- * creating the directory
- *
- * @return this path
- *
- * @throws UnsupportedOperationException
- * if the array contains an attribute that cannot be set atomically
- * when creating the directory
- * @throws FileAlreadyExistsException
- * if a directory could not otherwise be created because a file of
- * that name already exists <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkWrite(String) checkWrite}
- * method is invoked to check write access to the new directory.
- *
- * @see Files#createDirectories
- */
- public abstract Path createDirectory(FileAttribute<?>... attrs)
- throws IOException;
-
- /**
- * Opens or creates a file, returning a seekable byte channel to access the
- * file.
- *
- * <p> The {@code options} parameter determines how the file is opened.
- * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE WRITE}
- * options determine if the file should be opened for reading and/or writing.
- * If neither option (or the {@link StandardOpenOption#APPEND APPEND}
- * option) is contained in the array then the file is opened for reading.
- * By default reading or writing commences at the beginning of the file.
- *
- * <p> In the addition to {@code READ} and {@code WRITE}, the following
- * options may be present:
- *
- * <table border=1 cellpadding=5 summary="">
- * <tr> <th>Option</th> <th>Description</th> </tr>
- * <tr>
- * <td> {@link StandardOpenOption#APPEND APPEND} </td>
- * <td> If this option is present then the file is opened for writing and
- * each invocation of the channel's {@code write} method first advances
- * the position to the end of the file and then writes the requested
- * data. Whether the advancement of the position and the writing of the
- * data are done in a single atomic operation is system-dependent and
- * therefore unspecified. This option may not be used in conjunction
- * with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td>
- * </tr>
- * <tr>
- * <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>
- * <td> If this option is present then the existing file is truncated to
- * a size of 0 bytes. This option is ignored when the file is opened only
- * for reading. </td>
- * </tr>
- * <tr>
- * <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>
- * <td> If this option is present then a new file is created, failing if
- * the file already exists or is a symbolic link. When creating a file the
- * check for the existence of the file and the creation of the file if it
- * does not exist is atomic with respect to other file system operations.
- * This option is ignored when the file is opened only for reading. </td>
- * </tr>
- * <tr>
- * <td > {@link StandardOpenOption#CREATE CREATE} </td>
- * <td> If this option is present then an existing file is opened if it
- * exists, otherwise a new file is created. This option is ignored if the
- * {@code CREATE_NEW} option is also present or the file is opened only
- * for reading. </td>
- * </tr>
- * <tr>
- * <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>
- * <td> When this option is present then the implementation makes a
- * <em>best effort</em> attempt to delete the file when closed by the
- * {@link SeekableByteChannel#close close} method. If the {@code close}
- * method is not invoked then a <em>best effort</em> attempt is made to
- * delete the file when the Java virtual machine terminates. </td>
- * </tr>
- * <tr>
- * <td>{@link StandardOpenOption#SPARSE SPARSE} </td>
- * <td> When creating a new file this option is a <em>hint</em> that the
- * new file will be sparse. This option is ignored when not creating
- * a new file. </td>
- * </tr>
- * <tr>
- * <td> {@link StandardOpenOption#SYNC SYNC} </td>
- * <td> Requires that every update to the file's content or metadata be
- * written synchronously to the underlying storage device. (see <a
- * href="package-summary.html#integrity"> Synchronized I/O file
- * integrity</a>). </td>
- * <tr>
- * <tr>
- * <td> {@link StandardOpenOption#DSYNC DSYNC} </td>
- * <td> Requires that every update to the file's content be written
- * synchronously to the underlying storage device. (see <a
- * href="package-summary.html#integrity"> Synchronized I/O file
- * integrity</a>). </td>
- * </tr>
- * </table>
- *
- * <p> An implementation may also support additional implementation specific
- * options.
- *
- * <p> The {@code attrs} parameter is an optional array of file {@link
- * FileAttribute file-attributes} to set atomically when a new file is created.
- *
- * <p> In the case of the default provider, the returned seekable byte channel
- * is a {@link java.nio.channels.FileChannel}.
- *
- * <p> <b>Usage Examples:</b>
- * <pre>
- * Path file = ...
- *
- * // open file for reading
- * ReadableByteChannel rbc = file.newByteChannel(EnumSet.of(READ)));
- *
- * // open file for writing to the end of an existing file, creating
- * // the file if it doesn't already exist
- * WritableByteChannel wbc = file.newByteChannel(EnumSet.of(CREATE,APPEND));
- *
- * // create file with initial permissions, opening it for both reading and writing
- * FileAttribute<Set<PosixFilePermission>> perms = ...
- * SeekableByteChannel sbc = file.newByteChannel(EnumSet.of(CREATE_NEW,READ,WRITE), perms);
- * </pre>
- *
- * @param options
- * Options specifying how the file is opened
- * @param attrs
- * An optional list of file attributes to set atomically when
- * creating the file
- *
- * @return a new seekable byte channel
- *
- * @throws IllegalArgumentException
- * if the set contains an invalid combination of options
- * @throws UnsupportedOperationException
- * if an unsupported open option is specified or the array contains
- * attributes that cannot be set atomically when creating the file
- * @throws FileAlreadyExistsException
- * if a file of that name already exists and the {@link
- * StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
- * <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the path if the file is
- * opened for reading. The {@link SecurityManager#checkWrite(String)
- * checkWrite} method is invoked to check write access to the path
- * if the file is opened for writing.
- */
- public abstract SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,
- FileAttribute<?>... attrs)
- throws IOException;
-
- /**
- * Opens or creates a file, returning a seekable byte channel to access the
- * file.
- *
- * <p> This method opens or creates a file in exactly the manner specified
- * by the {@link Path#newByteChannel(Set,FileAttribute[]) newByteChannel}
- * method.
- *
- * @param options
- * options specifying how the file is opened
- *
- * @return a new seekable byte channel
- *
- * @throws IllegalArgumentException
- * if the set contains an invalid combination of options
- * @throws UnsupportedOperationException
- * if an unsupported open option is specified
- * @throws FileAlreadyExistsException
- * if a file of that name already exists and the {@link
- * StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
- * <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the path if the file is
- * opened for reading. The {@link SecurityManager#checkWrite(String)
- * checkWrite} method is invoked to check write access to the path
- * if the file is opened for writing.
- */
- public abstract SeekableByteChannel newByteChannel(OpenOption... options)
- throws IOException;
-
- /**
- * Opens or creates the file located by this object for writing, returning
- * an output stream to write bytes to the file.
- *
- * <p> This method opens or creates a file in exactly the manner specified
- * by the {@link Path#newByteChannel(Set,FileAttribute[]) newByteChannel}
- * method except that the {@link StandardOpenOption#READ READ} option may not
- * be present in the array of open options.
- *
- * @param options
- * options specifying how the file is opened
- *
- * @return a new output stream
- *
- * @throws IllegalArgumentException {@inheritDoc}
- * @throws UnsupportedOperationException {@inheritDoc}
- * @throws IOException {@inheritDoc}
- * @throws SecurityException {@inheritDoc}
- */
- @Override
- public abstract OutputStream newOutputStream(OpenOption... options)
- throws IOException;
-
- /**
- * Tells whether or not the file located by this object is considered
- * <em>hidden</em>. The exact definition of hidden is platform or provider
- * dependent. On UNIX for example a file is considered to be hidden if its
- * name begins with a period character ('.'). On Windows a file is
- * considered hidden if it isn't a directory and the DOS {@link
- * DosFileAttributes#isHidden hidden} attribute is set.
- *
- * <p> Depending on the implementation this method may require to access
- * the file system to determine if the file is considered hidden.
- *
- * @return {@code true} if the file is considered hidden
- *
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the file.
- */
- public abstract boolean isHidden() throws IOException;
-
- /**
- * Checks the existence and optionally the accessibility of the file
- * located by this path.
- *
- * <p> This method checks the existence of a file and that this Java virtual
- * machine has appropriate privileges that would allow it access the file
- * according to all of access modes specified in the {@code modes} parameter
- * as follows:
- *
- * <table border=1 cellpadding=5 summary="">
- * <tr> <th>Value</th> <th>Description</th> </tr>
- * <tr>
- * <td> {@link AccessMode#READ READ} </td>
- * <td> Checks that the file exists and that the Java virtual machine has
- * permission to read the file. </td>
- * </tr>
- * <tr>
- * <td> {@link AccessMode#WRITE WRITE} </td>
- * <td> Checks that the file exists and that the Java virtual machine has
- * permission to write to the file, </td>
- * </tr>
- * <tr>
- * <td> {@link AccessMode#EXECUTE EXECUTE} </td>
- * <td> Checks that the file exists and that the Java virtual machine has
- * permission to {@link Runtime#exec execute} the file. The semantics
- * may differ when checking access to a directory. For example, on UNIX
- * systems, checking for {@code EXECUTE} access checks that the Java
- * virtual machine has permission to search the directory in order to
- * access file or subdirectories. </td>
- * </tr>
- * </table>
- *
- * <p> If the {@code modes} parameter is of length zero, then the existence
- * of the file is checked.
- *
- * <p> This method follows symbolic links if the file referenced by this
- * object is a symbolic link. Depending on the implementation, this method
- * may require to read file permissions, access control lists, or other
- * file attributes in order to check the effective access to the file. To
- * determine the effective access to a file may require access to several
- * attributes and so in some implementations this method may not be atomic
- * with respect to other file system operations. Furthermore, as the result
- * of this method is immediately outdated, there is no guarantee that a
- * subsequence access will succeed (or even that it will access the same
- * file). Care should be taken when using this method in security sensitive
- * applications.
- *
- * @param modes
- * The access modes to check; may have zero elements
- *
- * @throws UnsupportedOperationException
- * an implementation is required to support checking for
- * {@code READ}, {@code WRITE}, and {@code EXECUTE} access. This
- * exception is specified to allow for the {@code Access} enum to
- * be extended in future releases.
- * @throws NoSuchFileException
- * if a file does not exist <i>(optional specific exception)</i>
- * @throws AccessDeniedException
- * the requested access would be denied or the access cannot be
- * determined because the Java virtual machine has insufficient
- * privileges or other reasons. <i>(optional specific exception)</i>
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * is invoked when checking read access to the file or only the
- * existence of the file, the {@link SecurityManager#checkWrite(String)
- * checkWrite} is invoked when checking write access to the file,
- * and {@link SecurityManager#checkExec(String) checkExec} is invoked
- * when checking execute access.
- */
- public abstract void checkAccess(AccessMode... modes) throws IOException;
-
- /**
- * Tests whether the file located by this path exists.
- *
- * <p> This convenience method is intended for cases where it is required to
- * take action when it can be confirmed that a file exists. This method simply
- * invokes the {@link #checkAccess checkAccess} method to check if the file
- * exists. If the {@code checkAccess} method succeeds then this method returns
- * {@code true}, otherwise if an {@code IOException} is thrown (because the
- * file doesn't exist or cannot be accessed by this Java virtual machine)
- * then {@code false} is returned.
- *
- * <p> Note that the result of this method is immediately outdated. If this
- * method indicates the file exists then there is no guarantee that a
- * subsequence access will succeed. Care should be taken when using this
- * method in security sensitive applications.
- *
- * @return {@code true} if the file exists; {@code false} if the file does
- * not exist or its existence cannot be determined.
- *
- * @throws SecurityException
- * In the case of the default provider, the {@link
- * SecurityManager#checkRead(String)} is invoked to check
- * read access to the file.
- *
- * @see #notExists
- */
- public abstract boolean exists();
-
- /**
- * Tests whether the file located by this path does not exist.
- *
- * <p> This convenience method is intended for cases where it is required to
- * take action when it can be confirmed that a file does not exist. This
- * method invokes the {@link #checkAccess checkAccess} method to check if the
- * file exists. If the file does not exist then {@code true} is returned,
- * otherwise the file exists or cannot be accessed by this Java virtual
- * machine and {@code false} is returned.
- *
- * <p> Note that this method is not the complement of the {@link #exists
- * exists} method. Where it is not possible to determine if a file exists
- * or not then both methods return {@code false}. As with the {@code exists}
- * method, the result of this method is immediately outdated. If this
- * method indicates the file does exist then there is no guarantee that a
- * subsequence attempt to create the file will succeed. Care should be taken
- * when using this method in security sensitive applications.
- *
- * @return {@code true} if the file does not exist; {@code false} if the
- * file exists or its existence cannot be determined.
- *
- * @throws SecurityException
- * In the case of the default provider, the {@link
- * SecurityManager#checkRead(String)} is invoked to check
- * read access to the file.
- */
- public abstract boolean notExists();
-
- /**
- * Returns the {@link FileStore} representing the file store where an
- * existing file, located by this path, is stored.
- *
- * <p> Once a reference to the {@code FileStore} is obtained it is
- * implementation specific if operations on the returned {@code FileStore},
- * or {@link FileStoreAttributeView} objects obtained from it, continue
- * to depend on the existence of the file. In particular the behavior is not
- * defined for the case that the file is deleted or moved to a different
- * file store.
- *
- * @return the file store where the file is stored
- *
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to the file, and in
- * addition it checks {@link RuntimePermission}<tt>
- * ("getFileStoreAttributes")</tt>
- */
- public abstract FileStore getFileStore() throws IOException;
-
// -- watchable --
/**
* Registers the file located by this path with a watch service.
*
* <p> In this release, this path locates a directory that exists. The
* directory is registered with the watch service so that entries in the
! * directory can be watched. The {@code events} parameter is an array of
! * events to register and may contain the following events:
* <ul>
* <li>{@link StandardWatchEventKind#ENTRY_CREATE ENTRY_CREATE} -
* entry created or moved into the directory</li>
* <li>{@link StandardWatchEventKind#ENTRY_DELETE ENTRY_DELETE} -
* entry deleted or moved out of the directory</li>
--- 565,603 ----
* method is invoked to check read access to the file, and where
* this path is not absolute, its {@link SecurityManager#checkPropertyAccess(String)
* checkPropertyAccess} method is invoked to check access to the
* system property {@code user.dir}
*/
! Path toRealPath(boolean resolveLinks) throws IOException;
/**
! * Returns a {@link File} object representing this path. Where this {@code
! * Path} is associated with the default provider, then this method is
! * equivalent to returning a {@code File} object constructed with the
! * {@code String} representation of this path.
*
! * <p> If this path was created by invoking the {@code File} {@link
! * File#toPath toPath} method then there is no guarantee that the {@code
! * File} object returned by this method is {@link #equals equal} to the
! * original {@code File}.
*
! * @return a {@code File} object representing this path
*
* @throws UnsupportedOperationException
! * if this {@code Path} is not associated with the default provider
*/
! File toFile();
// -- watchable --
/**
* Registers the file located by this path with a watch service.
*
* <p> In this release, this path locates a directory that exists. The
* directory is registered with the watch service so that entries in the
! * directory can be watched. The {@code events} parameter is the events to
! * register and may contain the following events:
* <ul>
* <li>{@link StandardWatchEventKind#ENTRY_CREATE ENTRY_CREATE} -
* entry created or moved into the directory</li>
* <li>{@link StandardWatchEventKind#ENTRY_DELETE ENTRY_DELETE} -
* entry deleted or moved out of the directory</li>
*** 1487,1500 ****
* that locates the directory entry that is created, deleted, or modified.
*
* <p> The set of events may include additional implementation specific
* event that are not defined by the enum {@link StandardWatchEventKind}
*
! * <p> The {@code modifiers} parameter is an array of <em>modifiers</em>
! * that qualify how the directory is registered. This release does not
! * define any <em>standard</em> modifiers. The array may contain
! * implementation specific modifiers.
*
* <p> Where a file is registered with a watch service by means of a symbolic
* link then it is implementation specific if the watch continues to depend
* on the existence of the symbolic link after it is registered.
*
--- 610,623 ----
* that locates the directory entry that is created, deleted, or modified.
*
* <p> The set of events may include additional implementation specific
* event that are not defined by the enum {@link StandardWatchEventKind}
*
! * <p> The {@code modifiers} parameter specifies <em>modifiers</em> that
! * qualify how the directory is registered. This release does not define any
! * <em>standard</em> modifiers. It may contain implementation specific
! * modifiers.
*
* <p> Where a file is registered with a watch service by means of a symbolic
* link then it is implementation specific if the watch continues to depend
* on the existence of the symbolic link after it is registered.
*
*** 1523,1533 ****
* In the case of the default provider, and a security manager is
* installed, the {@link SecurityManager#checkRead(String) checkRead}
* method is invoked to check read access to the file.
*/
@Override
! public abstract WatchKey register(WatchService watcher,
WatchEvent.Kind<?>[] events,
WatchEvent.Modifier... modifiers)
throws IOException;
/**
--- 646,656 ----
* In the case of the default provider, and a security manager is
* installed, the {@link SecurityManager#checkRead(String) checkRead}
* method is invoked to check read access to the file.
*/
@Override
! WatchKey register(WatchService watcher,
WatchEvent.Kind<?>[] events,
WatchEvent.Modifier... modifiers)
throws IOException;
/**
*** 1571,1581 ****
* In the case of the default provider, and a security manager is
* installed, the {@link SecurityManager#checkRead(String) checkRead}
* method is invoked to check read access to the file.
*/
@Override
! public abstract WatchKey register(WatchService watcher,
WatchEvent.Kind<?>... events)
throws IOException;
// -- Iterable --
--- 694,704 ----
* In the case of the default provider, and a security manager is
* installed, the {@link SecurityManager#checkRead(String) checkRead}
* method is invoked to check read access to the file.
*/
@Override
! WatchKey register(WatchService watcher,
WatchEvent.Kind<?>... events)
throws IOException;
// -- Iterable --
*** 1589,1599 ****
* #getRoot root} component, if present, is not returned by the iterator.
*
* @return an iterator over the name elements of this path.
*/
@Override
! public abstract Iterator<Path> iterator();
// -- compareTo/equals/hashCode --
/**
* Compares two abstract paths lexicographically. The ordering defined by
--- 712,722 ----
* #getRoot root} component, if present, is not returned by the iterator.
*
* @return an iterator over the name elements of this path.
*/
@Override
! Iterator<Path> iterator();
// -- compareTo/equals/hashCode --
/**
* Compares two abstract paths lexicographically. The ordering defined by
*** 1607,1671 ****
* value less than zero if this path is lexicographically less than
* the argument, or a value greater than zero if this path is
* lexicographically greater than the argument
*/
@Override
! public abstract int compareTo(Path other);
/**
- * Tests if the file referenced by this object is the same file referenced
- * by another object.
- *
- * <p> If this {@code Path} and the given {@code Path} are {@link
- * #equals(Object) equal} then this method returns {@code true} without checking
- * if the file exists. If the {@code Path} and the given {@code Path}
- * are associated with different providers, or the given {@code Path} is
- * {@code null} then this method returns {@code false}. Otherwise, this method
- * checks if both {@code Paths} locate the same file, and depending on the
- * implementation, may require to open or access both files.
- *
- * <p> If the file system and files remain static, then this method implements
- * an equivalence relation for non-null {@code Paths}.
- * <ul>
- * <li>It is <i>reflexive</i>: for a non-null {@code Path} {@code f},
- * {@code f.isSameFile(f)} should return {@code true}.
- * <li>It is <i>symmetric</i>: for two non-null {@code Path}
- * {@code f} and {@code g}, {@code f.isSameFile(g)} will equal
- * {@code g.isSameFile(f)}.
- * <li>It is <i>transitive</i>: for three {@code Paths}
- * {@code f}, {@code g}, and {@code h}, if {@code f.isSameFile(g)} returns
- * {@code true} and {@code g.isSameFile(h)} returns {@code true}, then
- * {@code f.isSameFile(h)} will return return {@code true}.
- * </ul>
- *
- * @param other
- * the other file reference
- *
- * @return {@code true} if, and only if, this object and the given object
- * locate the same file
- *
- * @throws IOException
- * if an I/O error occurs
- * @throws SecurityException
- * In the case of the default provider, and a security manager is
- * installed, the {@link SecurityManager#checkRead(String) checkRead}
- * method is invoked to check read access to both files.
- *
- * @see java.nio.file.attribute.BasicFileAttributes#fileKey
- */
- public abstract boolean isSameFile(Path other) throws IOException;
-
- /**
* Tests this path for equality with the given object.
*
* <p> If the given object is not a Path, or is a Path associated with a
* different provider, then this method immediately returns {@code false}.
*
* <p> Whether or not two path are equal depends on the file system
* implementation. In some cases the paths are compared without regard
* to case, and others are case sensitive. This method does not access the
! * file system and the file is not required to exist.
*
* <p> This method satisfies the general contract of the {@link
* java.lang.Object#equals(Object) Object.equals} method. </p>
*
* @param other
--- 730,753 ----
* value less than zero if this path is lexicographically less than
* the argument, or a value greater than zero if this path is
* lexicographically greater than the argument
*/
@Override
! int compareTo(Path other);
/**
* Tests this path for equality with the given object.
*
* <p> If the given object is not a Path, or is a Path associated with a
* different provider, then this method immediately returns {@code false}.
*
* <p> Whether or not two path are equal depends on the file system
* implementation. In some cases the paths are compared without regard
* to case, and others are case sensitive. This method does not access the
! * file system and the file is not required to exist. Where required, the
! * {@link Files#isSameFile isSameFile} method may be used to check if two
! * paths locate the same file.
*
* <p> This method satisfies the general contract of the {@link
* java.lang.Object#equals(Object) Object.equals} method. </p>
*
* @param other
*** 1672,1683 ****
* the object to which this object is to be compared
*
* @return {@code true} if, and only if, the given object is a {@code Path}
* that is identical to this {@code Path}
*/
! @Override
! public abstract boolean equals(Object other);
/**
* Computes a hash code for this path.
*
* <p> The hash code is based upon the components of the path, and
--- 754,764 ----
* the object to which this object is to be compared
*
* @return {@code true} if, and only if, the given object is a {@code Path}
* that is identical to this {@code Path}
*/
! boolean equals(Object other);
/**
* Computes a hash code for this path.
*
* <p> The hash code is based upon the components of the path, and
*** 1684,1695 ****
* satisfies the general contract of the {@link Object#hashCode
* Object.hashCode} method.
*
* @return the hash-code value for this path
*/
! @Override
! public abstract int hashCode();
/**
* Returns the string representation of this path.
*
* <p> If this path was created by converting a path string using the
--- 765,775 ----
* satisfies the general contract of the {@link Object#hashCode
* Object.hashCode} method.
*
* @return the hash-code value for this path
*/
! int hashCode();
/**
* Returns the string representation of this path.
*
* <p> If this path was created by converting a path string using the
*** 1699,1706 ****
* <p> The returned path string uses the default name {@link
* FileSystem#getSeparator separator} to separate names in the path.
*
* @return the string representation of this path
*/
! @Override
! public abstract String toString();
}
--- 779,785 ----
* <p> The returned path string uses the default name {@link
* FileSystem#getSeparator separator} to separate names in the path.
*
* @return the string representation of this path
*/
! String toString();
}