/*

 * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.io;

import java.net.URI;

import java.net.URL;

import java.net.MalformedURLException;

import java.net.URISyntaxException;

import java.util.List;

import java.util.ArrayList;

import java.security.AccessController;

import java.security.SecureRandom;

import java.nio.file.Path;

import java.nio.file.FileSystems;

import sun.security.action.GetPropertyAction;

/**

 * An abstract representation of file and directory pathnames.

 *

 * <p> User interfaces and operating systems use system-dependent <em>pathname

 * strings</em> to name files and directories.  This class presents an

 * abstract, system-independent view of hierarchical pathnames.  An

 * <em>abstract pathname</em> has two components:

 *

 * <ol>

 * <li> An optional system-dependent <em>prefix</em> string,

 *      such as a disk-drive specifier, <code>"/"</code>&nbsp;for the UNIX root

 *      directory, or <code>"\\\\"</code>&nbsp;for a Microsoft Windows UNC pathname, and

 * <li> A sequence of zero or more string <em>names</em>.

 * </ol>

 *

 * The first name in an abstract pathname may be a directory name or, in the

 * case of Microsoft Windows UNC pathnames, a hostname.  Each subsequent name

 * in an abstract pathname denotes a directory; the last name may denote

 * either a directory or a file.  The <em>empty</em> abstract pathname has no

 * prefix and an empty name sequence.

 *

 * <p> The conversion of a pathname string to or from an abstract pathname is

 * inherently system-dependent.  When an abstract pathname is converted into a

 * pathname string, each name is separated from the next by a single copy of

 * the default <em>separator character</em>.  The default name-separator

 * character is defined by the system property <code>file.separator</code>, and

 * is made available in the public static fields <code>{@link

 * #separator}</code> and <code>{@link #separatorChar}</code> of this class.

 * When a pathname string is converted into an abstract pathname, the names

 * within it may be separated by the default name-separator character or by any

 * other name-separator character that is supported by the underlying system.

 *

 * <p> A pathname, whether abstract or in string form, may be either

 * <em>absolute</em> or <em>relative</em>.  An absolute pathname is complete in

 * that no other information is required in order to locate the file that it

 * denotes.  A relative pathname, in contrast, must be interpreted in terms of

 * information taken from some other pathname.  By default the classes in the

 * <code>java.io</code> package always resolve relative pathnames against the

 * current user directory.  This directory is named by the system property

 * <code>user.dir</code>, and is typically the directory in which the Java

 * virtual machine was invoked.

 *

 * <p> The <em>parent</em> of an abstract pathname may be obtained by invoking

 * the {@link #getParent} method of this class and consists of the pathname's

 * prefix and each name in the pathname's name sequence except for the last.

 * Each directory's absolute pathname is an ancestor of any <tt>File</tt>

 * object with an absolute abstract pathname which begins with the directory's

 * absolute pathname.  For example, the directory denoted by the abstract

 * pathname <tt>"/usr"</tt> is an ancestor of the directory denoted by the

 * pathname <tt>"/usr/local/bin"</tt>.

 *

 * <p> The prefix concept is used to handle root directories on UNIX platforms,

 * and drive specifiers, root directories and UNC pathnames on Microsoft Windows platforms,

 * as follows:

 *

 * <ul>

 *

 * <li> For UNIX platforms, the prefix of an absolute pathname is always

 * <code>"/"</code>.  Relative pathnames have no prefix.  The abstract pathname

 * denoting the root directory has the prefix <code>"/"</code> and an empty

 * name sequence.

 *

 * <li> For Microsoft Windows platforms, the prefix of a pathname that contains a drive

 * specifier consists of the drive letter followed by <code>":"</code> and

 * possibly followed by <code>"\\"</code> if the pathname is absolute.  The

 * prefix of a UNC pathname is <code>"\\\\"</code>; the hostname and the share

 * name are the first two names in the name sequence.  A relative pathname that

 * does not specify a drive has no prefix.

 *

 * </ul>

 *

 * <p> Instances of this class may or may not denote an actual file-system

 * object such as a file or a directory.  If it does denote such an object

 * then that object resides in a <i>partition</i>.  A partition is an

 * operating system-specific portion of storage for a file system.  A single

 * storage device (e.g. a physical disk-drive, flash memory, CD-ROM) may

 * contain multiple partitions.  The object, if any, will reside on the

 * partition <a name="partName">named</a> by some ancestor of the absolute

 * form of this pathname.

 *

 * <p> A file system may implement restrictions to certain operations on the

 * actual file-system object, such as reading, writing, and executing.  These

 * restrictions are collectively known as <i>access permissions</i>.  The file

 * system may have multiple sets of access permissions on a single object.

 * For example, one set may apply to the object's <i>owner</i>, and another

 * may apply to all other users.  The access permissions on an object may

 * cause some methods in this class to fail.

 *

 * <p> Instances of the <code>File</code> class are immutable; that is, once

 * created, the abstract pathname represented by a <code>File</code> object

 * will never change.

 *

 * <h4>Interoperability with {@code java.nio.file} package</h4>

 *

 * <p> The <a href="../../java/nio/file/package-summary.html">{@code java.nio.file}</a>

 * package defines interfaces and classes for the Java virtual machine to access

 * files, file attributes, and file systems. This API may be used to overcome

 * many of the limitations of the {@code java.io.File} class.

 * The {@link #toPath toPath} method may be used to obtain a {@link

 * Path} that uses the abstract path represented by a {@code File} object to

 * locate a file. The resulting {@code Path} may be used with the {@link

 * java.nio.file.Files} class to provide more efficient and extensive access to

 * additional file operations, file attributes, and I/O exceptions to help

 * diagnose errors when an operation on a file fails.

 *

 * @author  unascribed

 * @since   JDK1.0

 */

public class File

    implements Serializable, Comparable<File>

{

    /**

     * The FileSystem object representing the platform's local file system.

     */

    static private FileSystem fs = FileSystem.getFileSystem();

    /**

     * This abstract pathname's normalized pathname string.  A normalized

     * pathname string uses the default name-separator character and does not

     * contain any duplicate or redundant separators.

     *

     * @serial

     */

    private String path;

    /**

     * The length of this abstract pathname's prefix, or zero if it has no

     * prefix.

     */

    private transient int prefixLength;

    /**

     * Returns the length of this abstract pathname's prefix.

     * For use by FileSystem classes.

     */

    int getPrefixLength() {

        return prefixLength;

    }

    /**

     * The system-dependent default name-separator character.  This field is

     * initialized to contain the first character of the value of the system

     * property <code>file.separator</code>.  On UNIX systems the value of this

     * field is <code>'/'</code>; on Microsoft Windows systems it is <code>'\\'</code>.

     *

     * @see     java.lang.System#getProperty(java.lang.String)

     */

    public static final char separatorChar = fs.getSeparator();

    /**

     * The system-dependent default name-separator character, represented as a

     * string for convenience.  This string contains a single character, namely

     * <code>{@link #separatorChar}</code>.

     */

    public static final String separator = "" + separatorChar;

    /**

     * The system-dependent path-separator character.  This field is

     * initialized to contain the first character of the value of the system

     * property <code>path.separator</code>.  This character is used to

     * separate filenames in a sequence of files given as a <em>path list</em>.

     * On UNIX systems, this character is <code>':'</code>; on Microsoft Windows systems it

     * is <code>';'</code>.

     *

     * @see     java.lang.System#getProperty(java.lang.String)

     */

    public static final char pathSeparatorChar = fs.getPathSeparator();

    /**

     * The system-dependent path-separator character, represented as a string

     * for convenience.  This string contains a single character, namely

     * <code>{@link #pathSeparatorChar}</code>.

     */

    public static final String pathSeparator = "" + pathSeparatorChar;

    /* -- Constructors -- */

    /**

     * Internal constructor for already-normalized pathname strings.

     */

    private File(String pathname, int prefixLength) {

        this.path = pathname;

        this.prefixLength = prefixLength;

    }

    /**

     * Internal constructor for already-normalized pathname strings.

     * The parameter order is used to disambiguate this method from the

     * public(File, String) constructor.

     */

    private File(String child, File parent) {

        assert parent.path != null;

        assert (!parent.path.equals(""));

        this.path = fs.resolve(parent.path, child);

        this.prefixLength = parent.prefixLength;

    }

    /**

     * Creates a new <code>File</code> instance by converting the given

     * pathname string into an abstract pathname.  If the given string is

     * the empty string, then the result is the empty abstract pathname.

     *

     * @param   pathname  A pathname string

     * @throws  NullPointerException

     *          If the <code>pathname</code> argument is <code>null</code>

     */

    public File(String pathname) {

        if (pathname == null) {

            throw new NullPointerException();

        }

        this.path = fs.normalize(pathname);

        this.prefixLength = fs.prefixLength(this.path);

    }

    /* Note: The two-argument File constructors do not interpret an empty

       parent abstract pathname as the current user directory.  An empty parent

       instead causes the child to be resolved against the system-dependent

       directory defined by the FileSystem.getDefaultParent method.  On Unix

       this default is "/", while on Microsoft Windows it is "\\".  This is required for

       compatibility with the original behavior of this class. */

    /**

     * Creates a new <code>File</code> instance from a parent pathname string

     * and a child pathname string.

     *

     * <p> If <code>parent</code> is <code>null</code> then the new

     * <code>File</code> instance is created as if by invoking the

     * single-argument <code>File</code> constructor on the given

     * <code>child</code> pathname string.

     *

     * <p> Otherwise the <code>parent</code> pathname string is taken to denote

     * a directory, and the <code>child</code> pathname string is taken to

     * denote either a directory or a file.  If the <code>child</code> pathname

     * string is absolute then it is converted into a relative pathname in a

     * system-dependent way.  If <code>parent</code> is the empty string then

     * the new <code>File</code> instance is created by converting

     * <code>child</code> into an abstract pathname and resolving the result

     * against a system-dependent default directory.  Otherwise each pathname

     * string is converted into an abstract pathname and the child abstract

     * pathname is resolved against the parent.

     *

     * @param   parent  The parent pathname string

     * @param   child   The child pathname string

     * @throws  NullPointerException

     *          If <code>child</code> is <code>null</code>

     */

    public File(String parent, String child) {

        if (child == null) {

            throw new NullPointerException();

        }

        if (parent != null) {

            if (parent.equals("")) {

                this.path = fs.resolve(fs.getDefaultParent(),

                                       fs.normalize(child));

            } else {

                this.path = fs.resolve(fs.normalize(parent),

                                       fs.normalize(child));

            }

        } else {

            this.path = fs.normalize(child);

        }

        this.prefixLength = fs.prefixLength(this.path);

    }

    /**

     * Creates a new <code>File</code> instance from a parent abstract

     * pathname and a child pathname string.

     *

     * <p> If <code>parent</code> is <code>null</code> then the new

     * <code>File</code> instance is created as if by invoking the

     * single-argument <code>File</code> constructor on the given

     * <code>child</code> pathname string.

     *

     * <p> Otherwise the <code>parent</code> abstract pathname is taken to

     * denote a directory, and the <code>child</code> pathname string is taken

     * to denote either a directory or a file.  If the <code>child</code>

     * pathname string is absolute then it is converted into a relative

     * pathname in a system-dependent way.  If <code>parent</code> is the empty

     * abstract pathname then the new <code>File</code> instance is created by

     * converting <code>child</code> into an abstract pathname and resolving

     * the result against a system-dependent default directory.  Otherwise each

     * pathname string is converted into an abstract pathname and the child

     * abstract pathname is resolved against the parent.

     *

     * @param   parent  The parent abstract pathname

     * @param   child   The child pathname string

     * @throws  NullPointerException

     *          If <code>child</code> is <code>null</code>

     */

    public File(File parent, String child) {

        if (child == null) {

            throw new NullPointerException();

        }

        if (parent != null) {

            if (parent.path.equals("")) {

                this.path = fs.resolve(fs.getDefaultParent(),

                                       fs.normalize(child));

            } else {

                this.path = fs.resolve(parent.path,

                                       fs.normalize(child));

            }

        } else {

            this.path = fs.normalize(child);

        }

        this.prefixLength = fs.prefixLength(this.path);

    }

    /**

     * Creates a new <tt>File</tt> instance by converting the given

     * <tt>file:</tt> URI into an abstract pathname.

     *

     * <p> The exact form of a <tt>file:</tt> URI is system-dependent, hence

     * the transformation performed by this constructor is also

     * system-dependent.

     *

     * <p> For a given abstract pathname <i>f</i> it is guaranteed that

     *

     * <blockquote><tt>

     * new File(</tt><i>&nbsp;f</i><tt>.{@link #toURI() toURI}()).equals(</tt><i>&nbsp;f</i><tt>.{@link #getAbsoluteFile() getAbsoluteFile}())

     * </tt></blockquote>

     *

     * so long as the original abstract pathname, the URI, and the new abstract

     * pathname are all created in (possibly different invocations of) the same

     * Java virtual machine.  This relationship typically does not hold,

     * however, when a <tt>file:</tt> URI that is created in a virtual machine

     * on one operating system is converted into an abstract pathname in a

     * virtual machine on a different operating system.

     *

     * @param  uri

     *         An absolute, hierarchical URI with a scheme equal to

     *         <tt>"file"</tt>, a non-empty path component, and undefined

     *         authority, query, and fragment components

     *

     * @throws  NullPointerException

     *          If <tt>uri</tt> is <tt>null</tt>

     *

     * @throws  IllegalArgumentException

     *          If the preconditions on the parameter do not hold

     *

     * @see #toURI()

     * @see java.net.URI

     * @since 1.4

     */

    public File(URI uri) {

        // Check our many preconditions

        if (!uri.isAbsolute())

            throw new IllegalArgumentException("URI is not absolute");

        if (uri.isOpaque())

            throw new IllegalArgumentException("URI is not hierarchical");

        String scheme = uri.getScheme();

        if ((scheme == null) || !scheme.equalsIgnoreCase("file"))

            throw new IllegalArgumentException("URI scheme is not \"file\"");

        if (uri.getAuthority() != null)

            throw new IllegalArgumentException("URI has an authority component");

        if (uri.getFragment() != null)

            throw new IllegalArgumentException("URI has a fragment component");

        if (uri.getQuery() != null)

            throw new IllegalArgumentException("URI has a query component");

        String p = uri.getPath();

        if (p.equals(""))

            throw new IllegalArgumentException("URI path component is empty");

        // Okay, now initialize

        p = fs.fromURIPath(p);

        if (File.separatorChar != '/')

            p = p.replace('/', File.separatorChar);

        this.path = fs.normalize(p);

        this.prefixLength = fs.prefixLength(this.path);

    }

    /* -- Path-component accessors -- */

    /**

     * Returns the name of the file or directory denoted by this abstract

     * pathname.  This is just the last name in the pathname's name

     * sequence.  If the pathname's name sequence is empty, then the empty

     * string is returned.

     *

     * @return  The name of the file or directory denoted by this abstract

     *          pathname, or the empty string if this pathname's name sequence

     *          is empty

     */

    public String getName() {

        int index = path.lastIndexOf(separatorChar);

        if (index < prefixLength) return path.substring(prefixLength);

        return path.substring(index + 1);

    }

    /**

     * Returns the pathname string of this abstract pathname's parent, or

     * <code>null</code> if this pathname does not name a parent directory.

     *

     * <p> The <em>parent</em> of an abstract pathname consists of the

     * pathname's prefix, if any, and each name in the pathname's name

     * sequence except for the last.  If the name sequence is empty then

     * the pathname does not name a parent directory.

     *

     * @return  The pathname string of the parent directory named by this

     *          abstract pathname, or <code>null</code> if this pathname

     *          does not name a parent

     */

    public String getParent() {

        int index = path.lastIndexOf(separatorChar);

        if (index < prefixLength) {

            if ((prefixLength > 0) && (path.length() > prefixLength))

                return path.substring(0, prefixLength);

            return null;

        }

        return path.substring(0, index);

    }

    /**

     * Returns the abstract pathname of this abstract pathname's parent,

     * or <code>null</code> if this pathname does not name a parent

     * directory.

     *

     * <p> The <em>parent</em> of an abstract pathname consists of the

     * pathname's prefix, if any, and each name in the pathname's name

     * sequence except for the last.  If the name sequence is empty then

     * the pathname does not name a parent directory.

     *

     * @return  The abstract pathname of the parent directory named by this

     *          abstract pathname, or <code>null</code> if this pathname

     *          does not name a parent

     *

     * @since 1.2

     */

    public File getParentFile() {

        String p = this.getParent();

        if (p == null) return null;

        return new File(p, this.prefixLength);

    }

    /**

     * Converts this abstract pathname into a pathname string.  The resulting

     * string uses the {@link #separator default name-separator character} to

     * separate the names in the name sequence.

     *

     * @return  The string form of this abstract pathname

     */

    public String getPath() {

        return path;

    }

    /* -- Path operations -- */

    /**

     * Tests whether this abstract pathname is absolute.  The definition of

     * absolute pathname is system dependent.  On UNIX systems, a pathname is

     * absolute if its prefix is <code>"/"</code>.  On Microsoft Windows systems, a

     * pathname is absolute if its prefix is a drive specifier followed by

     * <code>"\\"</code>, or if its prefix is <code>"\\\\"</code>.

     *

     * @return  <code>true</code> if this abstract pathname is absolute,

     *          <code>false</code> otherwise

     */

    public boolean isAbsolute() {

        return fs.isAbsolute(this);

    }

    /**

     * Returns the absolute pathname string of this abstract pathname.

     *

     * <p> If this abstract pathname is already absolute, then the pathname

     * string is simply returned as if by the <code>{@link #getPath}</code>

     * method.  If this abstract pathname is the empty abstract pathname then

     * the pathname string of the current user directory, which is named by the

     * system property <code>user.dir</code>, is returned.  Otherwise this

     * pathname is resolved in a system-dependent way.  On UNIX systems, a

     * relative pathname is made absolute by resolving it against the current

     * user directory.  On Microsoft Windows systems, a relative pathname is made absolute

     * by resolving it against the current directory of the drive named by the

     * pathname, if any; if not, it is resolved against the current user

     * directory.

     *

     * @return  The absolute pathname string denoting the same file or

     *          directory as this abstract pathname

     *

     * @throws  SecurityException

     *          If a required system property value cannot be accessed.

     *

     * @see     java.io.File#isAbsolute()

     */

    public String getAbsolutePath() {

        return fs.resolve(this);

    }

    /**

     * Returns the absolute form of this abstract pathname.  Equivalent to

     * <code>new&nbsp;File(this.{@link #getAbsolutePath})</code>.

     *

     * @return  The absolute abstract pathname denoting the same file or

     *          directory as this abstract pathname

     *

     * @throws  SecurityException

     *          If a required system property value cannot be accessed.

     *

     * @since 1.2

     */

    public File getAbsoluteFile() {

        String absPath = getAbsolutePath();

        return new File(absPath, fs.prefixLength(absPath));

    }

    /**

     * Returns the canonical pathname string of this abstract pathname.

     *

     * <p> A canonical pathname is both absolute and unique.  The precise

     * definition of canonical form is system-dependent.  This method first

     * converts this pathname to absolute form if necessary, as if by invoking the

     * {@link #getAbsolutePath} method, and then maps it to its unique form in a

     * system-dependent way.  This typically involves removing redundant names

     * such as <tt>"."</tt> and <tt>".."</tt> from the pathname, resolving

     * symbolic links (on UNIX platforms), and converting drive letters to a

     * standard case (on Microsoft Windows platforms).

     *

     * <p> Every pathname that denotes an existing file or directory has a

     * unique canonical form.  Every pathname that denotes a nonexistent file

     * or directory also has a unique canonical form.  The canonical form of

     * the pathname of a nonexistent file or directory may be different from

     * the canonical form of the same pathname after the file or directory is

     * created.  Similarly, the canonical form of the pathname of an existing

     * file or directory may be different from the canonical form of the same

     * pathname after the file or directory is deleted.

     *

     * @return  The canonical pathname string denoting the same file or

     *          directory as this abstract pathname

     *

     * @throws  IOException

     *          If an I/O error occurs, which is possible because the

     *          construction of the canonical pathname may require

     *          filesystem queries

     *

     * @throws  SecurityException

     *          If a required system property value cannot be accessed, or

     *          if a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead}</code> method denies

     *          read access to the file

     *

     * @since   JDK1.1

     * @see     Path#toRealPath

     */

    public String getCanonicalPath() throws IOException {

        return fs.canonicalize(fs.resolve(this));

    }

    /**

     * Returns the canonical form of this abstract pathname.  Equivalent to

     * <code>new&nbsp;File(this.{@link #getCanonicalPath})</code>.

     *

     * @return  The canonical pathname string denoting the same file or

     *          directory as this abstract pathname

     *

     * @throws  IOException

     *          If an I/O error occurs, which is possible because the

     *          construction of the canonical pathname may require

     *          filesystem queries

     *

     * @throws  SecurityException

     *          If a required system property value cannot be accessed, or

     *          if a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead}</code> method denies

     *          read access to the file

     *

     * @since 1.2

     * @see     Path#toRealPath

     */

    public File getCanonicalFile() throws IOException {

        String canonPath = getCanonicalPath();

        return new File(canonPath, fs.prefixLength(canonPath));

    }

    private static String slashify(String path, boolean isDirectory) {

        String p = path;

        if (File.separatorChar != '/')

            p = p.replace(File.separatorChar, '/');

        if (!p.startsWith("/"))

            p = "/" + p;

        if (!p.endsWith("/") && isDirectory)

            p = p + "/";

        return p;

    }

    /**

     * Converts this abstract pathname into a <code>file:</code> URL.  The

     * exact form of the URL is system-dependent.  If it can be determined that

     * the file denoted by this abstract pathname is a directory, then the

     * resulting URL will end with a slash.

     *

     * @return  A URL object representing the equivalent file URL

     *

     * @throws  MalformedURLException

     *          If the path cannot be parsed as a URL

     *

     * @see     #toURI()

     * @see     java.net.URI

     * @see     java.net.URI#toURL()

     * @see     java.net.URL

     * @since   1.2

     *

     * @deprecated This method does not automatically escape characters that

     * are illegal in URLs.  It is recommended that new code convert an

     * abstract pathname into a URL by first converting it into a URI, via the

     * {@link #toURI() toURI} method, and then converting the URI into a URL

     * via the {@link java.net.URI#toURL() URI.toURL} method.

     */

    @Deprecated

    public URL toURL() throws MalformedURLException {

        return new URL("file", "", slashify(getAbsolutePath(), isDirectory()));

    }

    /**

     * Constructs a <tt>file:</tt> URI that represents this abstract pathname.

     *

     * <p> The exact form of the URI is system-dependent.  If it can be

     * determined that the file denoted by this abstract pathname is a

     * directory, then the resulting URI will end with a slash.

     *

     * <p> For a given abstract pathname <i>f</i>, it is guaranteed that

     *

     * <blockquote><tt>

     * new {@link #File(java.net.URI) File}(</tt><i>&nbsp;f</i><tt>.toURI()).equals(</tt><i>&nbsp;f</i><tt>.{@link #getAbsoluteFile() getAbsoluteFile}())

     * </tt></blockquote>

     *

     * so long as the original abstract pathname, the URI, and the new abstract

     * pathname are all created in (possibly different invocations of) the same

     * Java virtual machine.  Due to the system-dependent nature of abstract

     * pathnames, however, this relationship typically does not hold when a

     * <tt>file:</tt> URI that is created in a virtual machine on one operating

     * system is converted into an abstract pathname in a virtual machine on a

     * different operating system.

     *

     * <p> Note that when this abstract pathname represents a UNC pathname then

     * all components of the UNC (including the server name component) are encoded

     * in the {@code URI} path. The authority component is undefined, meaning

     * that it is represented as {@code null}. The {@link Path} class defines the

     * {@link Path#toUri toUri} method to encode the server name in the authority

     * component of the resulting {@code URI}. The {@link #toPath toPath} method

     * may be used to obtain a {@code Path} representing this abstract pathname.

     *

     * @return  An absolute, hierarchical URI with a scheme equal to

     *          <tt>"file"</tt>, a path representing this abstract pathname,

     *          and undefined authority, query, and fragment components

     * @throws SecurityException If a required system property value cannot

     * be accessed.

     *

     * @see #File(java.net.URI)

     * @see java.net.URI

     * @see java.net.URI#toURL()

     * @since 1.4

     */

    public URI toURI() {

        try {

            File f = getAbsoluteFile();

            String sp = slashify(f.getPath(), f.isDirectory());

            if (sp.startsWith("//"))

                sp = "//" + sp;

            return new URI("file", null, sp, null);

        } catch (URISyntaxException x) {

            throw new Error(x);         // Can't happen

        }

    }

    /* -- Attribute accessors -- */

    /**

     * Tests whether the application can read the file denoted by this

     * abstract pathname.

     *

     * @return  <code>true</code> if and only if the file specified by this

     *          abstract pathname exists <em>and</em> can be read by the

     *          application; <code>false</code> otherwise

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     */

    public boolean canRead() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return fs.checkAccess(this, FileSystem.ACCESS_READ);

    }

    /**

     * Tests whether the application can modify the file denoted by this

     * abstract pathname.

     *

     * @return  <code>true</code> if and only if the file system actually

     *          contains a file denoted by this abstract pathname <em>and</em>

     *          the application is allowed to write to the file;

     *          <code>false</code> otherwise.

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>

     *          method denies write access to the file

     */

    public boolean canWrite() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkWrite(path);

        }

        return fs.checkAccess(this, FileSystem.ACCESS_WRITE);

    }

    /**

     * Tests whether the file or directory denoted by this abstract pathname

     * exists.

     *

     * @return  <code>true</code> if and only if the file or directory denoted

     *          by this abstract pathname exists; <code>false</code> otherwise

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file or directory

     */

    public boolean exists() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return ((fs.getBooleanAttributes(this) & FileSystem.BA_EXISTS) != 0);

    }

    /**

     * Tests whether the file denoted by this abstract pathname is a

     * directory.

     *

     * <p> Where it is required to distinguish an I/O exception from the case

     * that the file is not a directory, or where several attributes of the

     * same file are required at the same time, then the {@link

     * java.nio.file.Files#readAttributes(Path,Class,LinkOption[])

     * Files.readAttributes} method may be used.

     *

     * @return <code>true</code> if and only if the file denoted by this

     *          abstract pathname exists <em>and</em> is a directory;

     *          <code>false</code> otherwise

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     */

    public boolean isDirectory() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return ((fs.getBooleanAttributes(this) & FileSystem.BA_DIRECTORY)

                != 0);

    }

    /**

     * Tests whether the file denoted by this abstract pathname is a normal

     * file.  A file is <em>normal</em> if it is not a directory and, in

     * addition, satisfies other system-dependent criteria.  Any non-directory

     * file created by a Java application is guaranteed to be a normal file.

     *

     * <p> Where it is required to distinguish an I/O exception from the case

     * that the file is not a normal file, or where several attributes of the

     * same file are required at the same time, then the {@link

     * java.nio.file.Files#readAttributes(Path,Class,LinkOption[])

     * Files.readAttributes} method may be used.

     *

     * @return  <code>true</code> if and only if the file denoted by this

     *          abstract pathname exists <em>and</em> is a normal file;

     *          <code>false</code> otherwise

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     */

    public boolean isFile() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return ((fs.getBooleanAttributes(this) & FileSystem.BA_REGULAR) != 0);

    }

    /**

     * Tests whether the file named by this abstract pathname is a hidden

     * file.  The exact definition of <em>hidden</em> is system-dependent.  On

     * UNIX systems, a file is considered to be hidden if its name begins with

     * a period character (<code>'.'</code>).  On Microsoft Windows systems, a file is

     * considered to be hidden if it has been marked as such in the filesystem.

     *

     * @return  <code>true</code> if and only if the file denoted by this

     *          abstract pathname is hidden according to the conventions of the

     *          underlying platform

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     *

     * @since 1.2

     */

    public boolean isHidden() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return ((fs.getBooleanAttributes(this) & FileSystem.BA_HIDDEN) != 0);

    }

    /**

     * Returns the time that the file denoted by this abstract pathname was

     * last modified.

     *

     * <p> Where it is required to distinguish an I/O exception from the case

     * where {@code 0L} is returned, or where several attributes of the

     * same file are required at the same time, or where the time of last

     * access or the creation time are required, then the {@link

     * java.nio.file.Files#readAttributes(Path,Class,LinkOption[])

     * Files.readAttributes} method may be used.

     *

     * @return  A <code>long</code> value representing the time the file was

     *          last modified, measured in milliseconds since the epoch

     *          (00:00:00 GMT, January 1, 1970), or <code>0L</code> if the

     *          file does not exist or if an I/O error occurs

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     */

    public long lastModified() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return fs.getLastModifiedTime(this);

    }

    /**

     * Returns the length of the file denoted by this abstract pathname.

     * The return value is unspecified if this pathname denotes a directory.

     *

     * <p> Where it is required to distinguish an I/O exception from the case

     * that {@code 0L} is returned, or where several attributes of the same file

     * are required at the same time, then the {@link

     * java.nio.file.Files#readAttributes(Path,Class,LinkOption[])

     * Files.readAttributes} method may be used.

     *

     * @return  The length, in bytes, of the file denoted by this abstract

     *          pathname, or <code>0L</code> if the file does not exist.  Some

     *          operating systems may return <code>0L</code> for pathnames

     *          denoting system-dependent entities such as devices or pipes.

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkRead(java.lang.String)}</code>

     *          method denies read access to the file

     */

    public long length() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(path);

        }

        return fs.getLength(this);

    }

    /* -- File operations -- */

    /**

     * Atomically creates a new, empty file named by this abstract pathname if

     * and only if a file with this name does not yet exist.  The check for the

     * existence of the file and the creation of the file if it does not exist

     * are a single operation that is atomic with respect to all other

     * filesystem activities that might affect the file.

     * <P>

     * Note: this method should <i>not</i> be used for file-locking, as

     * the resulting protocol cannot be made to work reliably. The

     * {@link java.nio.channels.FileLock FileLock}

     * facility should be used instead.

     *

     * @return  <code>true</code> if the named file does not exist and was

     *          successfully created; <code>false</code> if the named file

     *          already exists

     *

     * @throws  IOException

     *          If an I/O error occurred

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>

     *          method denies write access to the file

     *

     * @since 1.2

     */

    public boolean createNewFile() throws IOException {

        SecurityManager security = System.getSecurityManager();

        if (security != null) security.checkWrite(path);

        return fs.createFileExclusively(path);

    }

    /**

     * Deletes the file or directory denoted by this abstract pathname.  If

     * this pathname denotes a directory, then the directory must be empty in

     * order to be deleted.

     *

     * <p> Note that the {@link java.nio.file.Files} class defines the {@link

     * java.nio.file.Files#delete(Path) delete} method to throw an {@link IOException}

     * when a file cannot be deleted. This is useful for error reporting and to

     * diagnose why a file cannot be deleted.

     *

     * @return  <code>true</code> if and only if the file or directory is

     *          successfully deleted; <code>false</code> otherwise

     *

     * @throws  SecurityException

     *          If a security manager exists and its <code>{@link

     *          java.lang.SecurityManager#checkDelete}</code> method denies

     *          delete access to the file

     */

    public boolean delete() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkDelete(path);

        }

        return fs.delete(this);

    }

    /**

     * Requests that the file or directory denoted by this abstract

     * pathname be deleted when the virtual machine terminates.

     * Files (or directories) are deleted in the reverse order that

     * they are registered. Invoking this method to delete a file or

     * directory that is already registered for deletion has no effect.

     * Deletion will be attempted only for normal termination of the

     * virtual machine, as defined by the Java Language Specification.

     *

     * <p> Once deletion has been requested, it is not possible to cancel the

     * request.  This method should therefore be used with care.

     *

     * <P>

     * Note: this method should <i>not</i> be used for file-locking, as

     * the resulting protocol cannot be made to work reliably. The

     * {@link java.nio.channels.FileLock FileLock}

     * facility should be used instead.

     *

     * @throws  SecurityException