/*
 
* Copyright (c) 2000, 2013, 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
 
* decreases when it is {@link #truncate <i>truncated</i>}.
  
The
 
* 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
 
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&lt;?&gt;[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
     
* this method returns it is guaranteed that all changes made to the file
     
* since this channel was created, or since this method was last invoked,
     
* will have been written to that device.
  
This is useful for ensuring that
     
* critical information is not lost in the event of a system crash.
     
*
     
* <p> If the file does not reside on a local device then no such guarantee
     
* is made.
     
*
     
* <p> The <tt>metaData</tt> parameter can be used to limit the number of
     
* I/O operations that this method is required to perform.
  
Passing
     
* <tt>false</tt> for this parameter indicates that only updates to the
     
* file's content need be written to storage; passing <tt>true</tt>
     
* indicates that updates to both the file's content and metadata must be
     
* written, which generally requires at least one more I/O operation.
     
* Whether this parameter actually has any effect is dependent upon the
     
* underlying operating system and is therefore unspecified.
     
*
     
* <p> Invoking this method may cause an I/O operation to occur even if the
     
* channel was only opened for reading.
  
Some operating systems, for
     
* example, maintain a last-access time as part of a file's metadata, and
     
* this time is updated whenever the file is read.
  
Whether or not this is
     
* actually done is system-dependent and is therefore unspecified.
     
*
     
* <p> This method is only guaranteed to force changes that were made to
     
* this channel's file via the methods defined in this class.
  
It may or
     
* may not force changes that were made by modifying the content of a
     
* {@link MappedByteBuffer <i>mapped byte buffer</i>} obtained by
     
* invoking the {@link #map map} method.
  
Invoking the {@link
     
* MappedByteBuffer#force force} method of the mapped byte buffer will
     
* force changes made to the buffer's content to be written.
  
</p>
     
*
     
* @param
   
metaData
     
*
          
If <tt>true</tt> then this method is required to force changes
     
*
          
to both the file's content and metadata to be written to
     
*
          
storage; otherwise, it need only force content changes to be
     
*
          
written
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*/

    
public abstract void force(boolean metaData) throws IOException;

    
/**
     
* Transfers bytes from this channel's file to the given writable byte
     
* channel.
     
*
     
* <p> An attempt is made to read up to <tt>count</tt> bytes starting at
     
* the given <tt>position</tt> in this channel's file and write them to the
     
* target channel.
  
An invocation of this method may or may not transfer
     
* all of the requested bytes; whether or not it does so depends upon the
     
* natures and states of the channels.
  
Fewer than the requested number of
     
* bytes are transferred if this channel's file contains fewer than
     
* <tt>count</tt> bytes starting at the given <tt>position</tt>, or if the
     
* target channel is non-blocking and it has fewer than <tt>count</tt>
     
* bytes free in its output buffer.
     
*
     
* <p> This method does not modify this channel's position.
  
If the given
     
* position is greater than the file's current size then no bytes are
     
* transferred.
  
If the target channel has a position then bytes are
     
* written starting at that position and then the position is incremented
     
* by the number of bytes written.
     
*
     
* <p> This method is potentially much more efficient than a simple loop
     
* that reads from this channel and writes to the target channel.
  
Many
     
* operating systems can transfer bytes directly from the filesystem cache
     
* to the target channel without actually copying them.
  
</p>
     
*
     
* @param
  
position
     
*
         
The position within the file at which the transfer is to begin;
     
*
         
must be non-negative
     
*
     
* @param
  
count
     
*
         
The maximum number of bytes to be transferred; must be
     
*
         
non-negative
     
*
     
* @param
  
target
     
*
         
The target channel
     
*
     
* @return
  
The number of bytes, possibly zero,
     
*
          
that were actually transferred
     
*
     
* @throws IllegalArgumentException
     
*
         
If the preconditions on the parameters do not hold
     
*
     
* @throws
  
NonReadableChannelException
     
*
          
If this channel was not opened for reading
     
*
     
* @throws
  
NonWritableChannelException
     
*
          
If the target channel was not opened for writing
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If either this channel or the target channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes either channel
     
*
          
while the transfer is in progress
     
*
     
* @throws
  
ClosedByInterruptException
     
*
          
If another thread interrupts the current thread while the
     
*
          
transfer is in progress, thereby closing both channels and
     
*
          
setting the current thread's interrupt status
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*/

    
public abstract long transferTo(long position, long count,
                                    
WritableByteChannel target)
        
throws IOException;

    
/**
     
* Transfers bytes into this channel's file from the given readable byte
     
* channel.
     
*
     
* <p> An attempt is made to read up to <tt>count</tt> bytes from the
     
* source channel and write them to this channel's file starting at the
     
* given <tt>position</tt>.
  
An invocation of this method may or may not
     
* transfer all of the requested bytes; whether or not it does so depends
     
* upon the natures and states of the channels.
  
Fewer than the requested
     
* number of bytes will be transferred if the source channel has fewer than
     
* <tt>count</tt> bytes remaining, or if the source channel is non-blocking
     
* and has fewer than <tt>count</tt> bytes immediately available in its
     
* input buffer.
     
*
     
* <p> This method does not modify this channel's position.
  
If the given
     
* position is greater than the file's current size then no bytes are
     
* transferred.
  
If the source channel has a position then bytes are read
     
* starting at that position and then the position is incremented by the
     
* number of bytes read.
     
*
     
* <p> This method is potentially much more efficient than a simple loop
     
* that reads from the source channel and writes to this channel.
  
Many
     
* operating systems can transfer bytes directly from the source channel
     
* into the filesystem cache without actually copying them.
  
</p>
     
*
     
* @param
  
src
     
*
         
The source channel
     
*
     
* @param
  
position
     
*
         
The position within the file at which the transfer is to begin;
     
*
         
must be non-negative
     
*
     
* @param
  
count
     
*
         
The maximum number of bytes to be transferred; must be
     
*
         
non-negative
     
*
     
* @return
  
The number of bytes, possibly zero,
     
*
          
that were actually transferred
     
*
     
* @throws IllegalArgumentException
     
*
         
If the preconditions on the parameters do not hold
     
*
     
* @throws
  
NonReadableChannelException
     
*
          
If the source channel was not opened for reading
     
*
     
* @throws
  
NonWritableChannelException
     
*
          
If this channel was not opened for writing
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If either this channel or the source channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes either channel
     
*
          
while the transfer is in progress
     
*
     
* @throws
  
ClosedByInterruptException
     
*
          
If another thread interrupts the current thread while the
     
*
          
transfer is in progress, thereby closing both channels and
     
*
          
setting the current thread's interrupt status
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*/

    
public abstract long transferFrom(ReadableByteChannel src,
                                      
long position, long count)
        
throws IOException;

    
/**
     
* Reads a sequence of bytes from this channel into the given buffer,
     
* starting at the given file position.
     
*
     
* <p> This method works in the same manner as the {@link
     
* #read(ByteBuffer)} method, except that bytes are read starting at the
     
* given file position rather than at the channel's current position.
  
This
     
* method does not modify this channel's position.
  
If the given position
     
* is greater than the file's current size then no bytes are read.
  
</p>
     
*
     
* @param
  
dst
     
*
         
The buffer into which bytes are to be transferred
     
*
     
* @param
  
position
     
*
         
The file position at which the transfer is to begin;
     
*
         
must be non-negative
     
*
     
* @return
  
The number of bytes read, possibly zero, or <tt>-1</tt> if the
     
*
          
given position is greater than or equal to the file's current
     
*
          
size
     
*
     
* @throws
  
IllegalArgumentException
     
*
          
If the position is negative
     
*
     
* @throws
  
NonReadableChannelException
     
*
          
If this channel was not opened for reading
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes this channel
     
*
          
while the read operation is in progress
     
*
     
* @throws
  
ClosedByInterruptException
     
*
          
If another thread interrupts the current thread
     
*
          
while the read operation is in progress, thereby
     
*
          
closing the channel and setting the current thread's
     
*
          
interrupt status
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*/

    
public abstract int read(ByteBuffer dst, long position) throws IOException;

    
/**
     
* Writes a sequence of bytes to this channel from the given buffer,
     
* starting at the given file position.
     
*
     
* <p> This method works in the same manner as the {@link
     
* #write(ByteBuffer)} method, except that bytes are written starting at
     
* the given file position rather than at the channel's current position.
     
* This method does not modify this channel's position.
  
If the given
     
* position is greater than the file's current size then the file will 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
  
src
     
*
         
The buffer from which bytes are to be transferred
     
*
     
* @param
  
position
     
*
         
The file position at which the transfer is to begin;
     
*
         
must be non-negative
     
*
     
* @return
  
The number of bytes written, possibly zero
     
*
     
* @throws
  
IllegalArgumentException
     
*
          
If the position is negative
     
*
     
* @throws
  
NonWritableChannelException
     
*
          
If this channel was not opened for writing
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes this channel
     
*
          
while the write operation is in progress
     
*
     
* @throws
  
ClosedByInterruptException
     
*
          
If another thread interrupts the current thread
     
*
          
while the write operation is in progress, thereby
     
*
          
closing the channel and setting the current thread's
     
*
          
interrupt status
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*/

    
public abstract int write(ByteBuffer src, long position) throws IOException;


    
// -- Memory-mapped buffers --

    
/**
     
* A typesafe enumeration for file-mapping modes.
     
*
     
* @since 1.4
     
*
     
* @see java.nio.channels.FileChannel#map
     
*/

    
public static class MapMode {

        
/**
         
* Mode for a read-only mapping.
         
*/
        
public static final MapMode READ_ONLY
            
= new MapMode("READ_ONLY");

        
/**
         
* Mode for a read/write mapping.
         
*/
        
public static final MapMode READ_WRITE
            
= new MapMode("READ_WRITE");

        
/**
         
* Mode for a private (copy-on-write) mapping.
         
*/
        
public static final MapMode PRIVATE
            
= new MapMode("PRIVATE");

        
private final String name;

        
private MapMode(String name) {
            
this.name = name;
        
}

        
/**
         
* Returns a string describing this file-mapping mode.
         
*
         
* @return
  
A descriptive string
         
*/

        
public String toString() {
            
return name;
        
}

    
}

    
/**
     
* Maps a region of this channel's file directly into memory.
     
*
     
* <p> A region of a file may be mapped into memory in one of three modes:
     
* </p>
     
*
     
* <ul>
     
*
     
*
   
<li><p> <i>Read-only:</i> Any attempt to modify the resulting buffer
     
*
   
will cause a {@link java.nio.ReadOnlyBufferException} to be thrown.
     
*
   
({@link MapMode#READ_ONLY MapMode.READ_ONLY}) </p></li>
     
*
     
*
   
<li><p> <i>Read/write:</i> Changes made to the resulting buffer will
     
*
   
eventually be propagated to the file; they may or may not be made
     
*
   
visible to other programs that have mapped the same file.
  
({@link
     
*
   
MapMode#READ_WRITE MapMode.READ_WRITE}) </p></li>
     
*
     
*
   
<li><p> <i>Private:</i> Changes made to the resulting buffer will not
     
*
   
be propagated to the file and will not be visible to other programs
     
*
   
that have mapped the same file; instead, they will cause private
     
*
   
copies of the modified portions of the buffer to be created.
  
({@link
     
*
   
MapMode#PRIVATE MapMode.PRIVATE}) </p></li>
     
*
     
* </ul>
     
*
     
* <p> For a read-only mapping, this channel must have been opened for
     
* reading; for a read/write or private mapping, this channel must have
     
* been opened for both reading and writing.
     
*
     
* <p> The {@link MappedByteBuffer <i>mapped byte buffer</i>}
     
* returned by this method will have a position of zero and a limit and
     
* capacity of <tt>size</tt>; its mark will be undefined.
  
The buffer and
     
* the mapping that it represents will remain valid until the buffer itself
     
* is garbage-collected.
     
*
     
* <p> A mapping, once established, is not dependent upon the file channel
     
* that was used to create it.
  
Closing the channel, in particular, has no
     
* effect upon the validity of the mapping.
     
*
     
* <p> Many of the details of memory-mapped files are inherently dependent
     
* upon the underlying operating system and are therefore unspecified.
  
The
     
* behavior of this method when the requested region is not completely
     
* contained within this channel's file is unspecified.
  
Whether changes
     
* made to the content or size of the underlying file, by this program or
     
* another, are propagated to the buffer is unspecified.
  
The rate at which
     
* changes to the buffer are propagated to the file is unspecified.
     
*
     
* <p> For most operating systems, mapping a file into memory is more
     
* expensive than reading or writing a few tens of kilobytes of data via
     
* the usual {@link #read read} and {@link #write write} methods.
  
From the
     
* standpoint of performance it is generally only worth mapping relatively
     
* large files into memory.
  
</p>
     
*
     
* @param
  
mode
     
*
         
One of the constants {@link MapMode#READ_ONLY READ_ONLY}, {@link
     
*
         
MapMode#READ_WRITE READ_WRITE}, or {@link MapMode#PRIVATE
     
*
         
PRIVATE} defined in the {@link MapMode} class, according to
     
*
         
whether the file is to be mapped read-only, read/write, or
     
*
         
privately (copy-on-write), respectively
     
*
     
* @param
  
position
     
*
         
The position within the file at which the mapped region
     
*
         
is to start; must be non-negative
     
*
     
* @param
  
size
     
*
         
The size of the region to be mapped; must be non-negative and
     
*
         
no greater than
 

     
*
     
* @return
  
The mapped byte buffer
     
*
     
* @throws NonReadableChannelException
     
*
         
If the <tt>mode</tt> is {@link MapMode#READ_ONLY READ_ONLY} but
     
*
         
this channel was not opened for reading
     
*
     
* @throws NonWritableChannelException
     
*
         
If the <tt>mode</tt> is {@link MapMode#READ_WRITE READ_WRITE} or
     
*
         
{@link MapMode#PRIVATE PRIVATE} but this channel was not opened
     
*
         
for both reading and writing
     
*
     
* @throws IllegalArgumentException
     
*
         
If the preconditions on the parameters do not hold
     
*
     
* @throws IOException
     
*
         
If some other I/O error occurs
     
*
     
*
 

     
*
 

     
*/

    
public abstract MappedByteBuffer map(MapMode mode,
                                         
long position, long size)
        
throws IOException;


    
// -- Locks --

    
/**
     
* Acquires a lock on the given region of this channel's file.
     
*
     
* <p> An invocation of this method will block until the region can be
     
* locked, this channel is closed, or the invoking thread is interrupted,
     
* whichever comes first.
     
*
     
* <p> If this channel is closed by another thread during an invocation of
     
* this method then an {@link AsynchronousCloseException} will be thrown.
     
*
     
* <p> If the invoking thread is interrupted while waiting to acquire the
     
* lock then its interrupt status will be set and a {@link
     
* FileLockInterruptionException} will be thrown.
  
If the invoker's
     
* interrupt status is set when this method is invoked then that exception
     
* will be thrown immediately; the thread's interrupt status will not be
     
* changed.
     
*
     
* <p> The region specified by the <tt>position</tt> and <tt>size</tt>
     
* parameters need not be contained within, or even overlap, the actual
     
* underlying file.
  
Lock regions are fixed in size; if a locked region
     
* initially contains the end of the file and the file grows beyond the
     
* region then the new portion of the file will not be covered by the lock.
     
* If a file is expected to grow in size and a lock on the entire file is
     
* required then a region starting at zero, and no smaller than the
     
* expected maximum size of the file, should be locked.
  
The zero-argument
     
*
 
 
method simply locks a region of size {@link
     
* Long#MAX_VALUE}.
     
*
     
* <p> Some operating systems do not support shared locks, in which case a
     
* request for a shared lock is automatically converted into a request for
     
* an exclusive lock.
  
Whether the newly-acquired lock is shared or
     
* exclusive may be tested by invoking the resulting lock object's {@link
     
* FileLock#isShared() isShared} method.
     
*
     
* <p> File locks are held on behalf of the entire Java virtual machine.
     
* They are not suitable for controlling access to a file by multiple
     
* threads within the same virtual machine.
  
</p>
     
*
     
* @param
  
position
     
*
         
The position at which the locked region is to start; must be
     
*
         
non-negative
     
*
     
* @param
  
size
     
*
         
The size of the locked region; must be non-negative, and the sum
     
*
         
<tt>position</tt>&nbsp;+&nbsp;<tt>size</tt> must be non-negative
     
*
     
* @param
  
shared
     
*
         
<tt>true</tt> to request a shared lock, in which case this
     
*
         
channel must be open for reading (and possibly writing);
     
*
         
<tt>false</tt> to request an exclusive lock, in which case this
     
*
         
channel must be open for writing (and possibly reading)
     
*
     
* @return
  
A lock object representing the newly-acquired lock
     
*
     
* @throws
  
IllegalArgumentException
     
*
          
If the preconditions on the parameters do not hold
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes this channel while the invoking
     
*
          
thread is blocked in this method
     
*
     
* @throws
  
FileLockInterruptionException
     
*
          
If the invoking thread is interrupted while blocked in this
     
*
          
method
     
*
     
* @throws
  
OverlappingFileLockException
     
*
          
If a lock that overlaps the requested region is already held by
     
*
          
this Java virtual machine, or if another thread is already
     
*
          
blocked in this method and is attempting to lock an overlapping
     
*
          
region
     
*
     
* @throws
  
NonReadableChannelException
     
*
          
If <tt>shared</tt> is <tt>true</tt> this channel was not
     
*
          
opened for reading
     
*
     
* @throws
  
NonWritableChannelException
     
*
          
If <tt>shared</tt> is <tt>false</tt> but this channel was not
     
*
          
opened for writing
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*
     
* @see#lock()
     
* @see#tryLock()
     
* @see#tryLock(long,long,boolean)
     
*/

    
public abstract FileLock lock(long position, long size, boolean shared)
        
throws IOException;

    
/**
     
* Acquires an exclusive lock on this channel's file.
     
*
     
* <p> An invocation of this method of the form <tt>fc.lock()</tt> behaves
     
* in exactly the same way as the invocation
     
*
     
* <pre>
     
*fc.{@link #lock(long,long,boolean) lock}(0L, Long.MAX_VALUE, false) </pre>
     
*
     
* @return
  
A lock object representing the newly-acquired lock
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
AsynchronousCloseException
     
*
          
If another thread closes this channel while the invoking
     
*
          
thread is blocked in this method
     
*
     
* @throws
  
FileLockInterruptionException
     
*
          
If the invoking thread is interrupted while blocked in this
     
*
          
method
     
*
     
* @throws
  
OverlappingFileLockException
     
*
          
If a lock that overlaps the requested region is already held by
     
*
          
this Java virtual machine, or if another thread is already
     
*
          
blocked in this method and is attempting to lock an overlapping
     
*
          
region of the same file
     
*
     
* @throws
  
NonWritableChannelException
     
*
          
If this channel was not opened for writing
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*
     
* @see#lock(long,long,boolean)
     
* @see#tryLock()
     
* @see#tryLock(long,long,boolean)
     
*/

    
public final FileLock lock() throws IOException {
        
return lock(0L, Long.MAX_VALUE, false);
    
}

    
/**
     
* Attempts to acquire a lock on the given region of this channel's file.
     
*
     
* <p> This method does not block.
  
An invocation always returns
     
* immediately, either having acquired a lock on the requested region or
     
* having failed to do so.
  
If it fails to acquire a lock because an
     
* overlapping lock is held by another program then it returns
     
* <tt>null</tt>.
  
If it fails to acquire a lock for any other reason then
     
* an appropriate exception is thrown.
     
*
     
* <p> The region specified by the <tt>position</tt> and <tt>size</tt>
     
* parameters need not be contained within, or even overlap, the actual
     
* underlying file.
  
Lock regions are fixed in size; if a locked region
     
* initially contains the end of the file and the file grows beyond the
     
* region then the new portion of the file will not be covered by the lock.
     
* If a file is expected to grow in size and a lock on the entire file is
     
* required then a region starting at zero, and no smaller than the
     
* expected maximum size of the file, should be locked.
  
The zero-argument
     
*
 
 
method simply locks a region of size {@link
     
* Long#MAX_VALUE}.
     
*
     
* <p> Some operating systems do not support shared locks, in which case a
     
* request for a shared lock is automatically converted into a request for
     
* an exclusive lock.
  
Whether the newly-acquired lock is shared or
     
* exclusive may be tested by invoking the resulting lock object's {@link
     
* FileLock#isShared() isShared} method.
     
*
     
* <p> File locks are held on behalf of the entire Java virtual machine.
     
* They are not suitable for controlling access to a file by multiple
     
* threads within the same virtual machine.
  
</p>
     
*
     
* @param
  
position
     
*
         
The position at which the locked region is to start; must be
     
*
         
non-negative
     
*
     
* @param
  
size
     
*
         
The size of the locked region; must be non-negative, and the sum
     
*
         
<tt>position</tt>&nbsp;+&nbsp;<tt>size</tt> must be non-negative
     
*
     
* @param
  
shared
     
*
         
<tt>true</tt> to request a shared lock,
     
*
         
<tt>false</tt> to request an exclusive lock
     
*
     
* @return
  
A lock object representing the newly-acquired lock,
     
*
          
or <tt>null</tt> if the lock could not be acquired
     
*
          
because another program holds an overlapping lock
     
*
     
* @throws
  
IllegalArgumentException
     
*
          
If the preconditions on the parameters do not hold
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
OverlappingFileLockException
     
*
          
If a lock that overlaps the requested region is already held by
     
*
          
this Java virtual machine, or if another thread is already
     
*
          
blocked in this method and is attempting to lock an overlapping
     
*
          
region of the same file
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*
     
* @see#lock()
     
* @see#lock(long,long,boolean)
     
* @see#tryLock()
     
*/

    
public abstract FileLock tryLock(long position, long size, boolean shared)
        
throws IOException;

    
/**
     
* Attempts to acquire an exclusive lock on this channel's file.
     
*
     
* <p> An invocation of this method of the form <tt>fc.tryLock()</tt>
     
* behaves in exactly the same way as the invocation
     
*
     
* <pre>
     
*fc.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false) </pre>
     
*
     
* @return
  
A lock object representing the newly-acquired lock,
     
*
          
or <tt>null</tt> if the lock could not be acquired
     
*
          
because another program holds an overlapping lock
     
*
     
* @throws
  
ClosedChannelException
     
*
          
If this channel is closed
     
*
     
* @throws
  
OverlappingFileLockException
     
*
          
If a lock that overlaps the requested region is already held by
     
*
          
this Java virtual machine, or if another thread is already
     
*
          
blocked in this method and is attempting to lock an overlapping
     
*
          
region
     
*
     
* @throws
  
IOException
     
*
          
If some other I/O error occurs
     
*
     
* @see#lock()
     
* @see#lock(long,long,boolean)
     
* @see#tryLock(long,long,boolean)
     
*/

    
public final FileLock tryLock() throws IOException {
        
return tryLock(0L, Long.MAX_VALUE, false);
    
}

}