/*

 * Copyright (c) 2007, 2021, 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.nio.file;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Reader;

import java.io.UncheckedIOException;

import java.io.Writer;

import java.nio.channels.Channels;

import java.nio.channels.FileChannel;

import java.nio.channels.SeekableByteChannel;

import java.nio.charset.Charset;

import java.nio.charset.CharsetDecoder;

import java.nio.charset.CharsetEncoder;

import java.nio.charset.StandardCharsets;

import java.nio.file.attribute.BasicFileAttributeView;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.attribute.DosFileAttributes;   // javadoc

import java.nio.file.attribute.FileAttribute;

import java.nio.file.attribute.FileAttributeView;

import java.nio.file.attribute.FileOwnerAttributeView;

import java.nio.file.attribute.FileStoreAttributeView;

import java.nio.file.attribute.FileTime;

import java.nio.file.attribute.PosixFileAttributeView;

import java.nio.file.attribute.PosixFileAttributes;

import java.nio.file.attribute.PosixFilePermission;

import java.nio.file.attribute.UserPrincipal;

import java.nio.file.spi.FileSystemProvider;

import java.nio.file.spi.FileTypeDetector;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.Spliterator;

import java.util.Spliterators;

import java.util.function.BiPredicate;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import jdk.internal.util.ArraysSupport;

import sun.nio.ch.FileChannelImpl;

import sun.nio.cs.UTF_8;

import sun.nio.fs.AbstractFileSystemProvider;

/**

 * This class consists exclusively of static methods that operate on files,

 * directories, or other types of files.

 *

 * <p> In most cases, the methods defined here will delegate to the associated

 * file system provider to perform the file operations.

 *

 * @since 1.7

 */

public final class Files {

    // buffer size used for reading and writing

    private static final int BUFFER_SIZE = 8192;

    private Files() { }

    /**

     * Returns the {@code FileSystemProvider} to delegate to.

     */

    private static FileSystemProvider provider(Path path) {

        return path.getFileSystem().provider();

    }

    /**

     * Convert a Closeable to a Runnable by converting checked IOException

     * to UncheckedIOException

     */

    private static Runnable asUncheckedRunnable(Closeable c) {

        return () -> {

            try {

                c.close();

            } catch (IOException e) {

                throw new UncheckedIOException(e);

            }

        };

    }

    // -- File contents --

    /**

     * Opens a file, returning an input stream to read from the file. The stream

     * will not be buffered, and is not required to support the {@link

     * InputStream#mark mark} or {@link InputStream#reset reset} methods. The

     * stream will be safe for access by multiple concurrent threads. Reading

     * commences at the beginning of the file. Whether the returned stream is

     * <i>asynchronously closeable</i> and/or <i>interruptible</i> is highly

     * file system provider specific and therefore not specified.

     *

     * <p> The {@code options} parameter determines how the file is opened.

     * If no options are present then it is equivalent to opening the file with

     * the {@link StandardOpenOption#READ READ} option. In addition to the {@code

     * READ} option, an implementation may also support additional implementation

     * specific options.

     *

     * @param   path

     *          the path to the file to open

     * @param   options

     *          options specifying how the file is opened

     *

     * @return  a new input stream

     *

     * @throws  IllegalArgumentException

     *          if an invalid combination of options is specified

     * @throws  UnsupportedOperationException

     *          if an unsupported option is specified

     * @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 static InputStream newInputStream(Path path, OpenOption... options)

        throws IOException

    {

        return provider(path).newInputStream(path, options);

    }

    /**

     * Opens or creates a file, returning an output stream that may be used to

     * write bytes to the file. The resulting stream will not be buffered. The

     * stream will be safe for access by multiple concurrent threads. Whether

     * the returned stream is <i>asynchronously closeable</i> and/or

     * <i>interruptible</i> is highly file system provider specific and

     * therefore not specified.

     *

     * <p> This method opens or creates a file in exactly the manner specified

     * by the {@link #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}

     * method with the exception that the {@link StandardOpenOption#READ READ}

     * option may not be present in the array of options. If no options are

     * present then this method works as if the {@link StandardOpenOption#CREATE

     * CREATE}, {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING},

     * and {@link StandardOpenOption#WRITE WRITE} options are present. In other

     * words, it opens the file for writing, creating the file if it doesn't

     * exist, or initially truncating an existing {@link #isRegularFile

     * regular-file} to a size of {@code 0} if it exists.

     *

     * <p> <b>Usage Examples:</b>

     * <pre>

     *     Path path = ...

     *

     *     // truncate and overwrite an existing file, or create the file if

     *     // it doesn't initially exist

     *     OutputStream out = Files.newOutputStream(path);

     *

     *     // append to an existing file, fail if the file does not exist

     *     out = Files.newOutputStream(path, APPEND);

     *

     *     // append to an existing file, create file if it doesn't initially exist

     *     out = Files.newOutputStream(path, CREATE, APPEND);

     *

     *     // always create new file, failing if it already exists

     *     out = Files.newOutputStream(path, CREATE_NEW);

     * </pre>

     *

     * @param   path

     *          the path to the file to open or create

     * @param   options

     *          options specifying how the file is opened

     *

     * @return  a new output stream

     *

     * @throws  IllegalArgumentException

     *          if {@code options} contains an invalid combination of options

     * @throws  UnsupportedOperationException

     *          if an unsupported 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#checkWrite(String) checkWrite}

     *          method is invoked to check write access to the file. The {@link

     *          SecurityManager#checkDelete(String) checkDelete} method is

     *          invoked to check delete access if the file is opened with the

     *          {@code DELETE_ON_CLOSE} option.

     */

    public static OutputStream newOutputStream(Path path, OpenOption... options)

        throws IOException

    {

        return provider(path).newOutputStream(path, options);

    }

    /**

     * 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 present then the file is

     * opened for reading. By default reading or writing commence at the

     * beginning of the file.

     *

     * <p> In the addition to {@code READ} and {@code WRITE}, the following

     * options may be present:

     *

     * <table class="striped">

     * <caption style="display:none">Options</caption>

     * <thead>

     * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>

     * </thead>

     * <tbody>

     * <tr>

     *   <th scope="row"> {@link StandardOpenOption#APPEND APPEND} </th>

     *   <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>

     *   <th scope="row"> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </th>

     *   <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>

     *   <th scope="row"> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </th>

     *   <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>

     *   <th scope="row" > {@link StandardOpenOption#CREATE CREATE} </th>

     *   <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>

     *   <th scope="row" > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </th>

     *   <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>

     *   <th scope="row">{@link StandardOpenOption#SPARSE SPARSE} </th>

     *   <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>

     *   <th scope="row"> {@link StandardOpenOption#SYNC SYNC} </th>

     *   <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>

     *   <th scope="row"> {@link StandardOpenOption#DSYNC DSYNC} </th>

     *   <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>

     * </tbody>

     * </table>

     *

     * <p> An implementation may also support additional implementation specific

     * options.

     *

     * <p> The {@code attrs} parameter is optional {@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>{@code

     *     Path path = ...

     *

     *     // open file for reading

     *     ReadableByteChannel rbc = Files.newByteChannel(path, 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 = Files.newByteChannel(path, EnumSet.of(CREATE,APPEND));

     *

     *     // create file with initial permissions, opening it for both reading and writing

     *     FileAttribute<Set<PosixFilePermission>> perms = ...

     *     SeekableByteChannel sbc =

     *         Files.newByteChannel(path, EnumSet.of(CREATE_NEW,READ,WRITE), perms);

     * }</pre>

     *

     * @param   path

     *          the path to the file to open or create

     * @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

     *          and the file is being opened for writing <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. The {@link

     *          SecurityManager#checkDelete(String) checkDelete} method is

     *          invoked to check delete access if the file is opened with the

     *          {@code DELETE_ON_CLOSE} option.

     *

     * @see java.nio.channels.FileChannel#open(Path,Set,FileAttribute[])

     */

    public static SeekableByteChannel newByteChannel(Path path,

                                                     Set<? extends OpenOption> options,

                                                     FileAttribute<?>... attrs)

        throws IOException

    {

        return provider(path).newByteChannel(path, options, attrs);

    }

    /**

     * 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 #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}

     * method.

     *

     * @param   path

     *          the path to the file to open or create

     * @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

     *          and the file is being opened for writing <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. The {@link

     *          SecurityManager#checkDelete(String) checkDelete} method is

     *          invoked to check delete access if the file is opened with the

     *          {@code DELETE_ON_CLOSE} option.

     *

     * @see java.nio.channels.FileChannel#open(Path,OpenOption[])

     */

    public static SeekableByteChannel newByteChannel(Path path, OpenOption... options)

        throws IOException

    {

        Set<OpenOption> set;

        if (options.length == 0) {

            set = Collections.emptySet();

        } else {

            set = new HashSet<>();

            Collections.addAll(set, options);

        }

        return newByteChannel(path, set);

    }

    // -- Directories --

    private static class AcceptAllFilter

        implements DirectoryStream.Filter<Path>

    {

        private AcceptAllFilter() { }

        @Override

        public boolean accept(Path entry) { return true; }

        static final AcceptAllFilter FILTER = new AcceptAllFilter();

    }

    /**

     * Opens a directory, returning a {@link 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 Path#resolve(Path) resolving} the

     * name of the directory entry against {@code dir}.

     *

     * <p> When not using the try-with-resources construct, then 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   dir

     *          the path to the directory

     *

     * @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 static DirectoryStream<Path> newDirectoryStream(Path dir)

        throws IOException

    {

        return provider(dir).newDirectoryStream(dir, AcceptAllFilter.FILTER);

    }

    /**

     * Opens a directory, returning a {@link 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 Path#resolve(Path) resolving} the

     * name of the directory entry against {@code dir}. 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 = ...

     *     try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, "*.java")) {

     *         :

     *     }

     * </pre>

     *

     * <p> The globbing pattern is specified by the {@link

     * FileSystem#getPathMatcher getPathMatcher} method.

     *

     * <p> When not using the try-with-resources construct, then 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   dir

     *          the path to the directory

     * @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 static DirectoryStream<Path> newDirectoryStream(Path dir, String glob)

        throws IOException

    {

        // avoid creating a matcher if all entries are required.

        if (glob.equals("*"))

            return newDirectoryStream(dir);

        // create a matcher and return a filter that uses it.

        FileSystem fs = dir.getFileSystem();

        final PathMatcher matcher = fs.getPathMatcher("glob:" + glob);

        DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<>() {

            @Override

            public boolean accept(Path entry)  {

                return matcher.matches(entry.getFileName());

            }

        };

        return fs.provider().newDirectoryStream(dir, filter);

    }

    /**

     * Opens a directory, returning a {@link 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 Path#resolve(Path) resolving} the

     * name of the directory entry against {@code dir}. The entries returned by

     * the iterator are filtered by the given {@link DirectoryStream.Filter

     * filter}.

     *

     * <p> When not using the try-with-resources construct, then 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 {

     *             return (Files.size(file) > 8192L);

     *         }

     *     };

     *     Path dir = ...

     *     try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter)) {

     *         :

     *     }

     * </pre>

     *

     * @param   dir

     *          the path to the directory

     * @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 static DirectoryStream<Path> newDirectoryStream(Path dir,

                                                           DirectoryStream.Filter<? super Path> filter)

        throws IOException

    {

        return provider(dir).newDirectoryStream(dir, filter);

    }

    // -- Creation and deletion --

    private static final Set<OpenOption> DEFAULT_CREATE_OPTIONS =

        Set.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);

    /**

     * Creates a new and empty file, failing if the file already exists. 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 optional {@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   path

     *          the path to the file to create

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the file

     *

     * @return  the file

     *

     * @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 or the parent directory does not exist

     * @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 static Path createFile(Path path, FileAttribute<?>... attrs)

        throws IOException

    {

        newByteChannel(path, DEFAULT_CREATE_OPTIONS, attrs).close();

        return path;

    }

    /**

     * Creates a new directory. 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. The {@link #createDirectories createDirectories}

     * method should be used where it is required to create all nonexistent

     * parent directories first.

     *

     * <p> The {@code attrs} parameter is optional {@link FileAttribute

     * file-attributes} to set atomically when creating the directory. 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   dir

     *          the directory to create

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the directory

     *

     * @return  the directory

     *

     * @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 or the parent directory does not exist

     * @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.

     */

    public static Path createDirectory(Path dir, FileAttribute<?>... attrs)

        throws IOException

    {

        provider(dir).createDirectory(dir, attrs);

        return dir;

    }

    /**

     * Creates a directory by creating all nonexistent parent directories first.

     * Unlike the {@link #createDirectory createDirectory} method, an exception

     * is not thrown if the directory could not be created because it already

     * exists.

     *

     * <p> The {@code attrs} parameter is optional {@link FileAttribute

     * file-attributes} to set atomically when creating the nonexistent

     * directories. 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.

     *

     * <p> If this method fails, then it may do so after creating some, but not

     * all, of the parent directories.

     *

     * @param   dir

     *          the directory to create

     *

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the directory

     *

     * @return  the directory

     *

     * @throws  UnsupportedOperationException

     *          if the array contains an attribute that cannot be set atomically

     *          when creating the directory

     * @throws  FileAlreadyExistsException

     *          if {@code dir} exists but 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#checkWrite(String) checkWrite}

     *          method is invoked prior to attempting to create a directory and

     *          its {@link SecurityManager#checkRead(String) checkRead} is

     *          invoked for each parent directory that is checked. If {@code

     *          dir} is not an absolute path then its {@link Path#toAbsolutePath

     *          toAbsolutePath} may need to be invoked to get its absolute path.

     *          This may invoke the security manager's {@link

     *          SecurityManager#checkPropertyAccess(String) checkPropertyAccess}

     *          method to check access to the system property {@code user.dir}

     */

    public static Path createDirectories(Path dir, FileAttribute<?>... attrs)

        throws IOException

    {

        // attempt to create the directory

        try {

            createAndCheckIsDirectory(dir, attrs);

            return dir;

        } catch (FileAlreadyExistsException x) {

            // file exists and is not a directory

            throw x;

        } catch (IOException x) {

            // parent may not exist or other reason

        }

        SecurityException se = null;

        try {

            dir = dir.toAbsolutePath();

        } catch (SecurityException x) {

            // don't have permission to get absolute path

            se = x;

        }

        // find a descendant that exists

        Path parent = dir.getParent();

        while (parent != null) {

            try {

                provider(parent).checkAccess(parent);

                break;

            } catch (NoSuchFileException x) {

                // does not exist

            }

            parent = parent.getParent();

        }

        if (parent == null) {

            // unable to find existing parent

            if (se == null) {

                throw new FileSystemException(dir.toString(), null,

                    "Unable to determine if root directory exists");

            } else {

                throw se;

            }

        }

        // create directories

        Path child = parent;

        for (Path name: parent.relativize(dir)) {

            child = child.resolve(name);

            createAndCheckIsDirectory(child, attrs);

        }

        return dir;

    }

    /**

     * Used by createDirectories to attempt to create a directory. A no-op

     * if the directory already exists.

     */

    private static void createAndCheckIsDirectory(Path dir,

                                                  FileAttribute<?>... attrs)

        throws IOException

    {

        try {

            createDirectory(dir, attrs);

        } catch (FileAlreadyExistsException x) {

            if (!isDirectory(dir, LinkOption.NOFOLLOW_LINKS))

                throw x;

        }

    }

    /**

     * Creates a new empty file in the specified directory, using the given

     * prefix and suffix strings to generate its name. The resulting

     * {@code Path} is associated with the same {@code FileSystem} as the given

     * directory.

     *

     * <p> The details as to how the name of the file is constructed is

     * implementation dependent and therefore not specified. Where possible

     * the {@code prefix} and {@code suffix} are used to construct candidate

     * names in the same manner as the {@link

     * java.io.File#createTempFile(String,String,File)} method.

     *

     * <p> As with the {@code File.createTempFile} methods, this method is only

     * part of a temporary-file facility. Where used as a <em>work files</em>,

     * the resulting file may be opened using the {@link

     * StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} option so that the

     * file is deleted when the appropriate {@code close} method is invoked.

     * Alternatively, a {@link Runtime#addShutdownHook shutdown-hook}, or the

     * {@link java.io.File#deleteOnExit} mechanism may be used to delete the

     * file automatically.

     *

     * <p> The {@code attrs} parameter is optional {@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. When no file attributes are specified, then the

     * resulting file may have more restrictive access permissions to files

     * created by the {@link java.io.File#createTempFile(String,String,File)}

     * method.

     *

     * @param   dir

     *          the path to directory in which to create the file

     * @param   prefix

     *          the prefix string to be used in generating the file's name;

     *          may be {@code null}

     * @param   suffix

     *          the suffix string to be used in generating the file's name;

     *          may be {@code null}, in which case "{@code .tmp}" is used

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the file

     *

     * @return  the path to the newly created file that did not exist before

     *          this method was invoked

     *

     * @throws  IllegalArgumentException

     *          if the prefix or suffix parameters cannot be used to generate

     *          a candidate file name

     * @throws  UnsupportedOperationException

     *          if the array contains an attribute that cannot be set atomically

     *          when creating the directory

     * @throws  IOException

     *          if an I/O error occurs or {@code dir} does not exist

     * @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 file.

     */

    public static Path createTempFile(Path dir,

                                      String prefix,

                                      String suffix,

                                      FileAttribute<?>... attrs)

        throws IOException

    {

        return TempFileHelper.createTempFile(Objects.requireNonNull(dir),

                                             prefix, suffix, attrs);

    }

    /**

     * Creates an empty file in the default temporary-file directory, using

     * the given prefix and suffix to generate its name. The resulting {@code

     * Path} is associated with the default {@code FileSystem}.

     *

     * <p> This method works in exactly the manner specified by the

     * {@link #createTempFile(Path,String,String,FileAttribute[])} method for

     * the case that the {@code dir} parameter is the temporary-file directory.

     *

     * @param   prefix

     *          the prefix string to be used in generating the file's name;

     *          may be {@code null}

     * @param   suffix

     *          the suffix string to be used in generating the file's name;

     *          may be {@code null}, in which case "{@code .tmp}" is used

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the file

     *

     * @return  the path to the newly created file that did not exist before

     *          this method was invoked

     *

     * @throws  IllegalArgumentException

     *          if the prefix or suffix parameters cannot be used to generate

     *          a candidate file name

     * @throws  UnsupportedOperationException

     *          if the array contains an attribute that cannot be set atomically

     *          when creating the directory

     * @throws  IOException

     *          if an I/O error occurs or the temporary-file directory does not

     *          exist

     * @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 file.

     */

    public static Path createTempFile(String prefix,

                                      String suffix,

                                      FileAttribute<?>... attrs)

        throws IOException

    {

        return TempFileHelper.createTempFile(null, prefix, suffix, attrs);

    }

    /**

     * Creates a new directory in the specified directory, using the given

     * prefix to generate its name.  The resulting {@code Path} is associated

     * with the same {@code FileSystem} as the given directory.

     *

     * <p> The details as to how the name of the directory is constructed is

     * implementation dependent and therefore not specified. Where possible

     * the {@code prefix} is used to construct candidate names.

     *

     * <p> As with the {@code createTempFile} methods, this method is only

     * part of a temporary-file facility. A {@link Runtime#addShutdownHook

     * shutdown-hook}, or the {@link java.io.File#deleteOnExit} mechanism may be

     * used to delete the directory automatically.

     *

     * <p> The {@code attrs} parameter is optional {@link FileAttribute

     * file-attributes} to set atomically when creating the directory. 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   dir

     *          the path to directory in which to create the directory

     * @param   prefix

     *          the prefix string to be used in generating the directory's name;

     *          may be {@code null}

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the directory

     *

     * @return  the path to the newly created directory that did not exist before

     *          this method was invoked

     *

     * @throws  IllegalArgumentException

     *          if the prefix cannot be used to generate a candidate directory name

     * @throws  UnsupportedOperationException

     *          if the array contains an attribute that cannot be set atomically

     *          when creating the directory

     * @throws  IOException

     *          if an I/O error occurs or {@code dir} does not exist

     * @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 when creating the

     *          directory.

     */

    public static Path createTempDirectory(Path dir,

                                           String prefix,

                                           FileAttribute<?>... attrs)

        throws IOException

    {

        return TempFileHelper.createTempDirectory(Objects.requireNonNull(dir),

                                                  prefix, attrs);

    }

    /**

     * Creates a new directory in the default temporary-file directory, using

     * the given prefix to generate its name. The resulting {@code Path} is

     * associated with the default {@code FileSystem}.

     *

     * <p> This method works in exactly the manner specified by {@link

     * #createTempDirectory(Path,String,FileAttribute[])} method for the case

     * that the {@code dir} parameter is the temporary-file directory.

     *

     * @param   prefix

     *          the prefix string to be used in generating the directory's name;

     *          may be {@code null}

     * @param   attrs

     *          an optional list of file attributes to set atomically when

     *          creating the directory

     *

     * @return  the path to the newly created directory that did not exist before

     *          this method was invoked

     *

     * @throws  IllegalArgumentException

     *          if the prefix cannot be used to generate a candidate directory name

     * @throws  UnsupportedOperationException

     *          if the array contains an attribute that cannot be set atomically

     *          when creating the directory

     * @throws  IOException

     *          if an I/O error occurs or the temporary-file directory does not

     *          exist

     * @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 when creating the

     *          directory.

     */

    public static Path createTempDirectory(String prefix,

                                           FileAttribute<?>... attrs)

        throws IOException

    {

        return TempFileHelper.createTempDirectory(null, prefix, attrs);

    }

    /**

     * 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 optional {@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   link

     *          the path of the symbolic link to create

     * @param   target

     *          the target of the symbolic link

     * @param   attrs

     *          the array of attributes to set atomically when creating the

     *          symbolic link

     *

     * @return  the path to the symbolic link

     *

     * @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}{@code ("symbolic")}

     *          or its {@link SecurityManager#checkWrite(String) checkWrite}

     *          method denies write access to the path of the symbolic link.

     */

    public static Path createSymbolicLink(Path link, Path target,

                                          FileAttribute<?>... attrs)

        throws IOException

    {

        provider(link).createSymbolicLink(link, target, attrs);

        return link;

    }

    /**

     * Creates a new link (directory entry) for an existing file <i>(optional

     * operation)</i>.

     *

     * <p> The {@code link} parameter 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 {@code link} as the 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   link

     *          the link (directory entry) to create

     * @param   existing

     *          a path to an existing file

     *

     * @return  the path to the link (directory entry)

     *

     * @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}{@code ("hard")}

     *          or its {@link SecurityManager#checkWrite(String) checkWrite}

     *          method denies write access to either the link or the

     *          existing file.

     */

    public static Path createLink(Path link, Path existing) throws IOException {

        provider(link).createLink(link, existing);

        return link;

    }

    /**

     * Deletes a file.

     *

     * <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.

     * This method can be used with the {@link #walkFileTree walkFileTree}

     * method to delete a directory and all entries in the directory, or an

     * entire <i>file-tree</i> where required.

     *

     * <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.

     *

     * @param   path

     *          the path to the file to delete

     *

     * @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 static void delete(Path path) throws IOException {

        provider(path).delete(path);

    }

    /**

     * Deletes a file if it exists.

     *

     * <p> As with the {@link #delete(Path) delete(Path)} 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.

     *

     * @param   path

     *          the path to the file to delete

     *

     * @return  {@code true} if the file was deleted by this method; {@code

     *          false} if the file could not be deleted because it did not

     *          exist

     *

     * @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 static boolean deleteIfExists(Path path) throws IOException {

        return provider(path).deleteIfExists(path);

    }

    // -- Copying and moving files --

    /**

     * Copy a file to a target file.

     *

     * <p> This method copies a file to the target file with the {@code

     * options} parameter specifying how the copy is performed. By default, the

     * copy fails if the target file already exists or is a symbolic link,

     * except if the source and target are the {@link #isSameFile same} file, in

     * which case the method completes without copying the file. 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 #walkFileTree

     * walkFileTree} 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 may include any of the following:

     *

     * <table class="striped">

     * <caption style="display:none">Options</caption>

     * <thead>

     * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>

     * </thead>

     * <tbody>

     * <tr>

     *   <th scope="row"> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </th>

     *   <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>

     *   <th scope="row"> {@link StandardCopyOption#COPY_ATTRIBUTES COPY_ATTRIBUTES} </th>

     *   <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 stores. Copying of file timestamps may result in precision

     *     loss. </td>

     * </tr>

     * <tr>

     *   <th scope="row"> {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} </th>

     *   <td> Symbolic links are not followed. If the file 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>

     * </tbody>

     * </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 is 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.

     *

     * <p> <b>Usage Example:</b>

     * Suppose we want to copy a file into a directory, giving it the same file

     * name as the source file:

     * <pre>

     *     Path source = ...

     *     Path newdir = ...

     *     Files.copy(source, newdir.resolve(source.getFileName());

     * </pre>

     *

     * @param   source

     *          the path to the file to copy

     * @param   target

     *          the path to the target file (may be associated with a different

     *          provider to the source path)

     * @param   options

     *          options specifying how the copy should be done

     *

     * @return  the path to the target file

     *

     * @throws  UnsupportedOperationException

     *          if the array contains a copy option that is not supported

     * @throws  FileAlreadyExistsException

     *          if the target file exists but cannot be replaced because the

     *          {@code REPLACE_EXISTING} option is not specified <i>(optional

     *          specific exception)</i>

     * @throws  DirectoryNotEmptyException

     *          the {@code REPLACE_EXISTING} option is specified but the file

     *          cannot be replaced because it 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 static Path copy(Path source, Path target, CopyOption... options)

        throws IOException

    {

        FileSystemProvider provider = provider(source);

        if (provider(target) == provider) {

            // same provider

            provider.copy(source, target, options);

        } else {

            // different providers

            CopyMoveHelper.copyToForeignTarget(source, target, options);

        }

        return target;

    }

    /**

     * Move or rename a file to a target file.

     *

     * <p> By default, this method attempts to move the file to the target

     * file, 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

     * #copy copy} method in conjunction with the {@link

     * #walkFileTree Files.walkFileTree} utility method.

     *

     * <p> The {@code options} parameter may include any of the following:

     *

     * <table class="striped">

     * <caption style="display:none">Options</caption>

     * <thead>

     * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>

     * </thead>

     * <tbody>

     * <tr>

     *   <th scope="row"> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </th>

     *   <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>

     *   <th scope="row"> {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} </th>

     *   <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>

     * </tbody>

     * </table>

     *

     * <p> An implementation of this interface may support additional

     * implementation specific options.

     *

     * <p> Moving a file will copy the {@link

     * BasicFileAttributes#lastModifiedTime last-modified-time} to the target

     * file if supported by both source and target file stores. Copying of file

     * timestamps may result in precision loss. 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 an {@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.

     *

     * <p> <b>Usage Examples:</b>

     * Suppose we want to rename a file to "newname", keeping the file in the

     * same directory:

     * <pre>

     *     Path source = ...

     *     Files.move(source, source.resolveSibling("newname"));

     * </pre>

     * Alternatively, suppose we want to move a file to new directory, keeping

     * the same file name, and replacing any existing file of that name in the

     * directory:

     * <pre>

     *     Path source = ...

     *     Path newdir = ...

     *     Files.move(source, newdir.resolve(source.getFileName()), REPLACE_EXISTING);

     * </pre>

     *

     * @param   source

     *          the path to the file to move

     * @param   target

     *          the path to the target file (may be associated with a different

     *          provider to the source path)

     * @param   options

     *          options specifying how the move should be done

     *

     * @return  the path to the target file

     *

     * @throws  UnsupportedOperationException

     *          if the array contains a copy option that is not supported

     * @throws  FileAlreadyExistsException

     *          if the target file exists but cannot be replaced because the

     *          {@code REPLACE_EXISTING} option is not specified <i>(optional

     *          specific exception)</i>

     * @throws  DirectoryNotEmptyException

     *          the {@code REPLACE_EXISTING} option is specified but the file

     *          cannot be replaced because it is a non-empty directory, or the

     *          source is a non-empty directory containing entries that would

     *          be required to be moved <i>(optional specific exceptions)</i>

     * @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 static Path move(Path source, Path target, CopyOption... options)

        throws IOException

    {

        FileSystemProvider provider = provider(source);

        if (provider(target) == provider) {

            // same provider

            provider.move(source, target, options);

        } else {

            // different providers

            CopyMoveHelper.moveToForeignTarget(source, target, options);

        }

        return target;

    }

    // -- Miscellaneous --

    /**

     * 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 {@code link}.

     *

     * @param   link

     *          the path to the symbolic link

     *

     * @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 static Path readSymbolicLink(Path link) throws IOException {

        return provider(link).readSymbolicLink(link);

    }

    /**

     * Returns the {@link FileStore} representing the file store where a file

     * is located.

     *

     * <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.

     *

     * @param   path

     *          the path to the file

     *

     * @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}{@code ("getFileStoreAttributes")}

     */

    public static FileStore getFileStore(Path path) throws IOException {

        return provider(path).getFileStore(path);

    }

    /**

     * Tests if two paths locate the same file.

     *

     * <p> If both {@code Path} objects are {@link Path#equals(Object) equal}

     * then this method returns {@code true} without checking if the file exists.

     * If the two {@code Path} objects are associated with different providers

     * then this method returns {@code false}. Otherwise, this method checks if

     * both {@code Path} objects 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 {@code Path} {@code f},

     *     {@code isSameFile(f,f)} should return {@code true}.

     * <li>It is <i>symmetric</i>: for two {@code Paths} {@code f} and {@code g},

     *     {@code isSameFile(f,g)} will equal {@code isSameFile(g,f)}.

     * <li>It is <i>transitive</i>: for three {@code Paths}

     *     {@code f}, {@code g}, and {@code h}, if {@code isSameFile(f,g)} returns

     *     {@code true} and {@code isSameFile(g,h)} returns {@code true}, then

     *     {@code isSameFile(f,h)} will return {@code true}.

     * </ul>

     *

     * @param   path

     *          one path to the file

     * @param   path2

     *          the other path

     *

     * @return  {@code true} if, and only if, the two paths 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