/*

 * Copyright (c) 2000, 2012, 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.channels;

import java.io.*;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.spi.AbstractInterruptibleChannel;

import java.nio.file.*;

import java.nio.file.attribute.FileAttribute;

import java.nio.file.spi.*;

import java.util.Set;

import java.util.HashSet;

import java.util.Collections;

/**

 * A channel for reading, writing, mapping, and manipulating a file.

 *

 * <p> A file channel is a {@link SeekableByteChannel} that is connected to

 * a file. It has a current <i>position</i> within its file which can

 * be both {@link #position() <i>queried</i>} and {@link #position(long)

 * <i>modified</i>}.  The file itself contains a variable-length sequence

 * of bytes that can be read and written and whose current {@link #size

 * <i>size</i>} can be queried.  The size of the file increases

 * when bytes are written beyond its current size; the size of the file

 * file may also have some associated <i>metadata</i> such as access

 * permissions, content type, and last-modification time; this class does not

 * define methods for metadata access.

 *

 * <p> In addition to the familiar read, write, and close operations of byte

 * channels, this class defines the following file-specific operations: </p>

 *

 * <ul>

 *

 *   <li><p> Bytes may be {@link #read(ByteBuffer, long) read} or

 *   {@link #write(ByteBuffer, long) <i>written</i>} at an absolute

 *   position in a file in a way that does not affect the channel's current

 *   position.  </p></li>

 *

 *   <li><p> A region of a file may be {@link #map <i>mapped</i>}

 *   directly into memory; for large files this is often much more efficient

 *   than invoking the usual <tt>read</tt> or <tt>write</tt> methods.

 *   </p></li>

 *

 *   <li><p> Updates made to a file may be {@link #force <i>forced

 *   out</i>} to the underlying storage device, ensuring that data are not

 *   lost in the event of a system crash.  </p></li>

 *

 *   <li><p> Bytes can be transferred from a file {@link #transferTo <i>to

 *   some other channel</i>}, and {@link #transferFrom <i>vice

 *   versa</i>}, in a way that can be optimized by many operating systems

 *   into a very fast transfer directly to or from the filesystem cache.

 *   </p></li>

 *

 *   <li><p> A region of a file may be {@link FileLock <i>locked</i>}

 *   against access by other programs.  </p></li>

 *

 * </ul>

 *

 * <p> File channels are safe for use by multiple concurrent threads.  The

 * {@link Channel#close close} method may be invoked at any time, as specified

 * by the {@link Channel} interface.  Only one operation that involves the

 * channel's position or can change its file's size may be in progress at any

 * given time; attempts to initiate a second such operation while the first is

 * still in progress will block until the first operation completes.  Other

 * operations, in particular those that take an explicit position, may proceed

 * concurrently; whether they in fact do so is dependent upon the underlying

 * implementation and is therefore unspecified.

 *

 * <p> The view of a file provided by an instance of this class is guaranteed

 * to be consistent with other views of the same file provided by other

 * instances in the same program.  The view provided by an instance of this

 * class may or may not, however, be consistent with the views seen by other

 * concurrently-running programs due to caching performed by the underlying

 * operating system and delays induced by network-filesystem protocols.  This

 * is true regardless of the language in which these other programs are

 * written, and whether they are running on the same machine or on some other

 * machine.  The exact nature of any such inconsistencies are system-dependent

 * and are therefore unspecified.

 *

 * <p> A file channel is created by invoking one of the {@link #open open}

 * methods defined by this class. A file channel can also be obtained from an

 * existing {@link java.io.FileInputStream#getChannel FileInputStream}, {@link

 * java.io.FileOutputStream#getChannel FileOutputStream}, or {@link

 * java.io.RandomAccessFile#getChannel RandomAccessFile} object by invoking

 * that object's <tt>getChannel</tt> method, which returns a file channel that

 * is connected to the same underlying file. Where the file channel is obtained

 * from an existing stream or random access file then the state of the file

 * channel is intimately connected to that of the object whose <tt>getChannel</tt>

 * method returned the channel.  Changing the channel's position, whether

 * explicitly or by reading or writing bytes, will change the file position of

 * the originating object, and vice versa. Changing the file's length via the

 * file channel will change the length seen via the originating object, and vice

 * versa.  Changing the file's content by writing bytes will change the content

 * seen by the originating object, and vice versa.

 *

 * <a name="open-mode"></a> <p> At various points this class specifies that an

 * instance that is "open for reading," "open for writing," or "open for

 * reading and writing" is required.  A channel obtained via the {@link

 * java.io.FileInputStream#getChannel getChannel} method of a {@link

 * java.io.FileInputStream} instance will be open for reading.  A channel

 * obtained via the {@link java.io.FileOutputStream#getChannel getChannel}

 * method of a {@link java.io.FileOutputStream} instance will be open for

 * writing.  Finally, a channel obtained via the {@link

 * java.io.RandomAccessFile#getChannel getChannel} method of a {@link

 * java.io.RandomAccessFile} instance will be open for reading if the instance

 * was created with mode <tt>"r"</tt> and will be open for reading and writing

 * if the instance was created with mode <tt>"rw"</tt>.

 *

 * <a name="append-mode"></a><p> A file channel that is open for writing may be in

 * <i>append mode</i>, for example if it was obtained from a file-output stream

 * that was created by invoking the {@link

 * java.io.FileOutputStream#FileOutputStream(java.io.File,boolean)

 * FileOutputStream(File,boolean)} constructor and passing <tt>true</tt> for

 * the second parameter.  In this mode each invocation of a relative write

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

 *

 * @see java.io.FileInputStream#getChannel()

 * @see java.io.FileOutputStream#getChannel()

 * @see java.io.RandomAccessFile#getChannel()

 *

 * @author Mark Reinhold

 * @author Mike McCloskey

 * @author JSR-51 Expert Group

 * @since 1.4

 */

public abstract class FileChannel

    extends AbstractInterruptibleChannel

    implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel

{

    /**

     * Initializes a new instance of this class.

     */

    protected FileChannel() { }

    /**

     * Opens or creates a file, returning a file channel to access the file.

     *

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

     * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE

     * WRITE} options determine if the file should be opened for reading and/or

     * writing. If neither option (or the {@link StandardOpenOption#APPEND APPEND}

     * option) is contained in the array then the file is opened for reading.

     * By default reading or writing commences at the beginning of the file.

     *

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

     * options may be present:

     *

     * <table border=1 cellpadding=5 summary="">

     * <tr> <th>Option</th> <th>Description</th> </tr>

     * <tr>

     *   <td> {@link StandardOpenOption#APPEND APPEND} </td>

     *   <td> If this option is present then the file is opened for writing and

     *     each invocation of the channel's {@code write} method first advances

     *     the position to the end of the file and then writes the requested

     *     data. Whether the advancement of the position and the writing of the

     *     data are done in a single atomic operation is system-dependent and

     *     therefore unspecified. This option may not be used in conjunction

     *     with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td>

     * </tr>

     * <tr>

     *   <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>

     *   <td> If this option is present then the existing file is truncated to

     *   a size of 0 bytes. This option is ignored when the file is opened only

     *   for reading. </td>

     * </tr>

     * <tr>

     *   <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>

     *   <td> If this option is present then a new file is created, failing if

     *   the file already exists. When creating a file the check for the

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

     *   is atomic with respect to other file system operations. This option is

     *   ignored when the file is opened only for reading. </td>

     * </tr>

     * <tr>

     *   <td > {@link StandardOpenOption#CREATE CREATE} </td>

     *   <td> If this option is present then an existing file is opened if it

     *   exists, otherwise a new file is created. 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 if the {@code CREATE_NEW} option is also present or

     *   the file is opened only for reading. </td>

     * </tr>

     * <tr>

     *   <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>

     *   <td> When this option is present then the implementation makes a

     *   <em>best effort</em> attempt to delete the file when closed by the

     *   the {@link #close close} method. If the {@code close} method is not

     *   invoked then a <em>best effort</em> attempt is made to delete the file

     *   when the Java virtual machine terminates. </td>

     * </tr>

     * <tr>

     *   <td>{@link StandardOpenOption#SPARSE SPARSE} </td>

     *   <td> When creating a new file this option is a <em>hint</em> that the

     *   new file will be sparse. This option is ignored when not creating

     *   a new file. </td>

     * </tr>

     * <tr>

     *   <td> {@link StandardOpenOption#SYNC SYNC} </td>

     *   <td> Requires that every update to the file's content or metadata be

     *   written synchronously to the underlying storage device. (see <a

     *   href="../file/package-summary.html#integrity"> Synchronized I/O file

     *   integrity</a>). </td>

     * <tr>

     * <tr>

     *   <td> {@link StandardOpenOption#DSYNC DSYNC} </td>

     *   <td> Requires that every update to the file's content be written

     *   synchronously to the underlying storage device. (see <a

     *   href="../file/package-summary.html#integrity"> Synchronized I/O file

     *   integrity</a>). </td>

     * </tr>

     * </table>

     *

     * <p> An implementation may also support additional options.

     *

     * <p> The {@code attrs} parameter is an optional array of file {@link

     * FileAttribute file-attributes} to set atomically when creating the file.

     *

     * <p> The new channel is created by invoking the {@link

     * FileSystemProvider#newFileChannel newFileChannel} method on the

     * provider that created the {@code Path}.

     *

     * @param   path

     *          The path of 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 file channel

     *

     * @throws  IllegalArgumentException

     *          If the set contains an invalid combination of options

     * @throws  UnsupportedOperationException

     *          If the {@code path} is associated with a provider that does not

     *          support creating file channels, or an unsupported open option is

     *          specified, or the array contains an attribute that cannot be set

     *          atomically when creating the file

     * @throws  IOException

     *          If an I/O error occurs

     * @throws  SecurityException

     *          If a security manager is installed and it denies an

     *          unspecified permission required by the implementation.

     *          In the case of the default provider, the {@link

     *          SecurityManager#checkRead(String)} method is invoked to check

     *          read access if the file is opened for reading. The {@link

     *          SecurityManager#checkWrite(String)} method is invoked to check

     *          write access if the file is opened for writing

     *

     * @since   1.7

     */

    public static FileChannel open(Path path,

                                   Set<? extends OpenOption> options,

                                   FileAttribute<?>... attrs)

        throws IOException

    {

        FileSystemProvider provider = path.getFileSystem().provider();

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

    }

    @SuppressWarnings({"unchecked", "rawtypes"}) // generic array construction

    private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0];

    /**

     * Opens or creates a file, returning a file channel to access the file.

     *

     * <p> An invocation of this method behaves in exactly the same way as the

     * invocation

     * <pre>

     *     fc.{@link #open(Path,Set,FileAttribute[]) open}(file, opts, new FileAttribute<?>[0]);

     * </pre>

     * where {@code opts} is a set of the options specified in the {@code

     * options} array.

     *

     * @param   path

     *          The path of the file to open or create

     * @param   options

     *          Options specifying how the file is opened

     *

     * @return  A new file channel

     *

     * @throws  IllegalArgumentException

     *          If the set contains an invalid combination of options

     * @throws  UnsupportedOperationException

     *          If the {@code path} is associated with a provider that does not

     *          support creating file channels, or an unsupported open option is

     *          specified

     * @throws  IOException

     *          If an I/O error occurs

     * @throws  SecurityException

     *          If a security manager is installed and it denies an

     *          unspecified permission required by the implementation.

     *          In the case of the default provider, the {@link

     *          SecurityManager#checkRead(String)} method is invoked to check

     *          read access if the file is opened for reading. The {@link

     *          SecurityManager#checkWrite(String)} method is invoked to check

     *          write access if the file is opened for writing

     *

     * @since   1.7

     */

    public static FileChannel open(Path path, OpenOption... options)

        throws IOException

    {

        Set<OpenOption> set = new HashSet<OpenOption>(options.length);

        Collections.addAll(set, options);

        return open(path, set, NO_ATTRIBUTES);

    }

    // -- Channel operations --

    /**

     * Reads a sequence of bytes from this channel into the given buffer.

     *

     * <p> Bytes are read starting at this channel's current file position, and

     * then the file position is updated with the number of bytes actually

     * read.  Otherwise this method behaves exactly as specified in the {@link

     * ReadableByteChannel} interface. </p>

     */

    public abstract int read(ByteBuffer dst) throws IOException;

    /**

     * Reads a sequence of bytes from this channel into a subsequence of the

     * given buffers.

     *

     * <p> Bytes are read starting at this channel's current file position, and

     * then the file position is updated with the number of bytes actually

     * read.  Otherwise this method behaves exactly as specified in the {@link

     * ScatteringByteChannel} interface.  </p>

     */

    public abstract long read(ByteBuffer[] dsts, int offset, int length)

        throws IOException;

    /**

     * Reads a sequence of bytes from this channel into the given buffers.

     *

     * <p> Bytes are read starting at this channel's current file position, and

     * then the file position is updated with the number of bytes actually

     * read.  Otherwise this method behaves exactly as specified in the {@link

     * ScatteringByteChannel} interface.  </p>

     */

    public final long read(ByteBuffer[] dsts) throws IOException {

        return read(dsts, 0, dsts.length);

    }

    /**

     * Writes a sequence of bytes to this channel from the given buffer.

     *

     * <p> Bytes are written starting at this channel's current file position

     * unless the channel is in append mode, in which case the position is

     * first advanced to the end of the file.  The file is grown, if necessary,

     * to accommodate the written bytes, and then the file position is updated

     * with the number of bytes actually written.  Otherwise this method

     * behaves exactly as specified by the {@link WritableByteChannel}

     * interface. </p>

     */

    public abstract int write(ByteBuffer src) throws IOException;

    /**

     * Writes a sequence of bytes to this channel from a subsequence of the

     * given buffers.

     *

     * <p> Bytes are written starting at this channel's current file position

     * unless the channel is in append mode, in which case the position is

     * first advanced to the end of the file.  The file is grown, if necessary,

     * to accommodate the written bytes, and then the file position is updated

     * with the number of bytes actually written.  Otherwise this method

     * behaves exactly as specified in the {@link GatheringByteChannel}

     * interface.  </p>

     */

    public abstract long write(ByteBuffer[] srcs, int offset, int length)

        throws IOException;

    /**

     * Writes a sequence of bytes to this channel from the given buffers.

     *

     * <p> Bytes are written starting at this channel's current file position

     * unless the channel is in append mode, in which case the position is

     * first advanced to the end of the file.  The file is grown, if necessary,

     * to accommodate the written bytes, and then the file position is updated

     * with the number of bytes actually written.  Otherwise this method

     * behaves exactly as specified in the {@link GatheringByteChannel}

     * interface.  </p>

     */

    public final long write(ByteBuffer[] srcs) throws IOException {

        return write(srcs, 0, srcs.length);

    }

    // -- Other operations --

    /**

     * Returns this channel's file position.

     *

     * @return  This channel's file position,

     *          a non-negative integer counting the number of bytes

     *          from the beginning of the file to the current position

     *

     * @throws  ClosedChannelException

     *          If this channel is closed

     *

     * @throws  IOException

     *          If some other I/O error occurs

     */

    public abstract long position() throws IOException;

    /**

     * Sets this channel's file position.

     *

     * <p> Setting the position to a value that is greater than the file's

     * current size is legal but does not change the size of the file.  A later

     * attempt to read bytes at such a position will immediately return an

     * end-of-file indication.  A later attempt to write bytes at such a

     * position will cause the file to be grown to accommodate the new bytes;

     * the values of any bytes between the previous end-of-file and the

     * newly-written bytes are unspecified.  </p>

     *

     * @param  newPosition

     *         The new position, a non-negative integer counting

     *         the number of bytes from the beginning of the file

     *

     * @return  This file channel

     *

     * @throws  ClosedChannelException

     *          If this channel is closed

     *

     * @throws  IllegalArgumentException

     *          If the new position is negative

     *

     * @throws  IOException

     *          If some other I/O error occurs

     */

    public abstract FileChannel position(long newPosition) throws IOException;

    /**

     * Returns the current size of this channel's file.

     *

     * @return  The current size of this channel's file,

     *          measured in bytes

     *

     * @throws  ClosedChannelException

     *          If this channel is closed

     *

     * @throws  IOException

     *          If some other I/O error occurs

     */

    public abstract long size() throws IOException;

    /**

     * Truncates this channel's file to the given size.

     *

     * <p> If the given size is less than the file's current size then the file

     * is truncated, discarding any bytes beyond the new end of the file.  If

     * the given size is greater than or equal to the file's current size then

     * the file is not modified.  In either case, if this channel's file

     * position is greater than the given size then it is set to that size.

     * </p>

     *

     * @param  size

     *         The new size, a non-negative byte count

     *

     * @return  This file channel

     *

     * @throws  NonWritableChannelException

     *          If this channel was not opened for writing

     *

     * @throws  ClosedChannelException

     *          If this channel is closed

     *

     * @throws  IllegalArgumentException

     *          If the new size is negative

     *

     * @throws  IOException

     *          If some other I/O error occurs

     */

    public abstract FileChannel truncate(long size) throws IOException;

    /**

     * Forces any updates to this channel's file to be written to the storage

     * device that contains it.

     *

     * <p> If this channel's file resides on a local storage device then when