org.eclipse.rdf4j.common.io

## Class NioFile

- java.lang.Object
- - org.eclipse.rdf4j.common.io.NioFile

- All Implemented Interfaces:
    Closeable, AutoCloseable

      public final class NioFile
      extends Object
      implements Closeable

  File wrapper that protects against concurrent file closing events due to e.g. `thread interrupts`. In case the file channel that is used by this class is closed due to such an event, it will try to reopen the channel. The thread that causes the `ClosedByInterruptException` is not protected, assuming the interrupt is intended to end the thread's operation.
  Author:
    Arjohn Kampman

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `NioFile(File file)` Constructor Opens a file in read/write mode, creating a new one if the file doesn't exist.
    `NioFile(File file, String mode)` Constructor Opens a file in a specific mode, creating a new one if the file doesn't exist.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()`
    `boolean` | `delete()` Close any open channels and then deletes the file.
    `void` | `force(boolean metaData)` Performs a protected `FileChannel.force(boolean)` call.
    `File` | `getFile()`
    `boolean` | `isClosed()` Check if a file was closed explicitly.
    `int` | `read(ByteBuffer buf, long offset)` Performs a protected `FileChannel.read(ByteBuffer, long)` call.
    `byte` | `readByte(long offset)` Read single byte from channel starting at offset.
    `byte[]` | `readBytes(long offset, int length)` Read a byte array of a specific length from channel starting at offset.
    `int` | `readInt(long offset)` Read integer value from channel starting at offset.
    `long` | `readLong(long offset)` Read long value from channel starting at offset.
    `long` | `size()` Performs a protected `FileChannel.size()` call.
    `long` | `transferTo(long position, long count, WritableByteChannel target)` Performs a protected `FileChannel.transferTo(long, long, WritableByteChannel)` call.
    `void` | `truncate(long size)` Performs a protected `FileChannel.truncate(long)` call.
    `int` | `write(ByteBuffer buf, long offset)` Performs a protected `FileChannel.write(ByteBuffer, long)` call.
    `void` | `writeByte(byte value, long offset)` Write single byte to channel starting at offset.
    `void` | `writeBytes(byte[] value, long offset)` Write byte array to channel starting at offset.
    `void` | `writeInt(int value, long offset)` Write integer value to channel starting at offset.
    `void` | `writeLong(long value, long offset)` Write long value to channel starting at offset.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### NioFile

          public NioFile(File file)
                  throws IOException

      Constructor Opens a file in read/write mode, creating a new one if the file doesn't exist.
      Parameters:
        `file` -
      Throws:
        `IOException`

    - #### NioFile

          public NioFile(File file,
                         String mode)
                  throws IOException

      Constructor Opens a file in a specific mode, creating a new one if the file doesn't exist.
      Parameters:
        `file` - file
        `mode` - file mode
      Throws:
        `IOException`

  - ### Method Detail

    - #### close

          public void close()
                     throws IOException

      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Throws:
        `IOException`

    - #### isClosed

          public boolean isClosed()

      Check if a file was closed explicitly.
      Returns:
        true if it was closed explicitly

    - #### getFile

          public File getFile()

    - #### delete

          public boolean delete()
                         throws IOException

      Close any open channels and then deletes the file.
      Returns:
        `true` if the file has been deleted successfully, `false` otherwise.
      Throws:
        `IOException` - If there was a problem closing the open file channel.

    - #### force

          public void force(boolean metaData)
                     throws IOException

      Performs a protected `FileChannel.force(boolean)` call.
      Parameters:
        `metaData` -
      Throws:
        `IOException`

    - #### truncate

          public void truncate(long size)
                        throws IOException

      Performs a protected `FileChannel.truncate(long)` call.
      Parameters:
        `size` -
      Throws:
        `IOException`

    - #### size

          public long size()
                    throws IOException

      Performs a protected `FileChannel.size()` call.
      Returns:
        size of the file
      Throws:
        `IOException`

    - #### transferTo

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

      Performs a protected `FileChannel.transferTo(long, long, WritableByteChannel)` call.
      Parameters:
        `position` - position within the file
        `count` - number of bytes to transfer
        `target` - target channel
      Returns:
        number of bytes transferred
      Throws:
        `IOException`

    - #### write

          public int write(ByteBuffer buf,
                           long offset)
                    throws IOException

      Performs a protected `FileChannel.write(ByteBuffer, long)` call.
      Parameters:
        `buf` - buffer
        `offset` - non-negative offset
      Returns:
        number of bytes written
      Throws:
        `IOException`

    - #### read

          public int read(ByteBuffer buf,
                          long offset)
                   throws IOException

      Performs a protected `FileChannel.read(ByteBuffer, long)` call.
      Parameters:
        `buf` - buffer to read
        `offset` - non-negative offset
      Returns:
        number of bytes read
      Throws:
        `IOException`

    - #### writeBytes

          public void writeBytes(byte[] value,
                                 long offset)
                          throws IOException

      Write byte array to channel starting at offset.
      Parameters:
        `value` - byte array to write
        `offset` - non-negative offset
      Throws:
        `IOException`

    - #### readBytes

          public byte[] readBytes(long offset,
                                  int length)
                           throws IOException

      Read a byte array of a specific length from channel starting at offset.
      Parameters:
        `offset` -
        `length` -
      Returns:
        byte array
      Throws:
        `IOException`

    - #### writeByte

          public void writeByte(byte value,
                                long offset)
                         throws IOException

      Write single byte to channel starting at offset.
      Parameters:
        `value` - value to write
        `offset` - non-negative offset
      Throws:
        `IOException`

    - #### readByte

          public byte readByte(long offset)
                        throws IOException

      Read single byte from channel starting at offset.
      Parameters:
        `offset` - non-negative offset
      Returns:
        byte
      Throws:
        `IOException`

    - #### writeLong

          public void writeLong(long value,
                                long offset)
                         throws IOException

      Write long value to channel starting at offset.
      Parameters:
        `value` - value to write
        `offset` - non-negative offset
      Throws:
        `IOException`

    - #### readLong

          public long readLong(long offset)
                        throws IOException

      Read long value from channel starting at offset.
      Parameters:
        `offset` - non-negative offset
      Returns:
        long
      Throws:
        `IOException`

    - #### writeInt

          public void writeInt(int value,
                               long offset)
                        throws IOException

      Write integer value to channel starting at offset.
      Parameters:
        `value` - value to write
        `offset` - non-negative offset
      Throws:
        `IOException`

    - #### readInt

          public int readInt(long offset)
                      throws IOException

      Read integer value from channel starting at offset.
      Parameters:
        `offset` - non-negative offset
      Returns:
        integer
      Throws:
        `IOException`

Copyright © 2015-2021 Eclipse Foundation. All Rights Reserved.