org.apache.pdfbox.io

## Class RandomAccessBufferedFileInputStream

- java.lang.Object
- - java.io.InputStream
  - - org.apache.pdfbox.io.RandomAccessBufferedFileInputStream

All Implemented Interfaces:
  Closeable, AutoCloseable, RandomAccessRead

    public class RandomAccessBufferedFileInputStream
    extends InputStream
    implements RandomAccessRead

Provides `InputStream` access to portions of a file combined with buffered reading of content. Start of next bytes to read can be set via seek method. File is accessed via `RandomAccessFile` and is read in byte chunks which are cached.

Author:
  Timo Boehme

### Constructor Summary

Constructors
Constructor and Description
`RandomAccessBufferedFileInputStream(File file)` Create a random access input stream instance for the given file.
`RandomAccessBufferedFileInputStream(InputStream input)` Create a random access input stream for the given input stream by copying the data to a temporary file.
`RandomAccessBufferedFileInputStream(String filename)` Create a random access input stream instance for the file with the given name.

### Method Summary

All Methods Instance Methods Concrete Methods
`int` `available()` Returns an estimate of the number of bytes that can be read.
`void` `close()`
`long` `getPosition()` Returns offset in file at which next byte would be read.
`boolean` `isClosed()` Returns true if this stream has been closed.
`boolean` `isEOF()` A simple test to see if we are at the end of the data.
`long` `length()` The total number of bytes that are available.
`int` `peek()` This will peek at the next byte.
`int` `read()` Read a single byte of data.
`int` `read(byte[] b)` Read a buffer of data.
`int` `read(byte[] b, int off, int len)` Read a buffer of data.
`byte[]` `readFully(int length)` Reads a given number of bytes.
`void` `rewind(int bytes)` Seek backwards the given number of bytes.
`void` `seek(long newOffset)` Seeks to new position.
`long` `skip(long n)`

### Methods inherited from class java.io.InputStream

`mark, markSupported, reset`

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

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

### Constructor Detail

#### RandomAccessBufferedFileInputStream

    public RandomAccessBufferedFileInputStream(String filename)
                                        throws IOException

Create a random access input stream instance for the file with the given name.

Parameters:
  `filename` - the filename of the file to be read.
Throws:
  `IOException` - if something went wrong while accessing the given file.

#### RandomAccessBufferedFileInputStream

    public RandomAccessBufferedFileInputStream(File file)
                                        throws IOException

Create a random access input stream instance for the given file.

Parameters:
  `file` - the file to be read.
Throws:
  `IOException` - if something went wrong while accessing the given file.

#### RandomAccessBufferedFileInputStream

    public RandomAccessBufferedFileInputStream(InputStream input)
                                        throws IOException

Create a random access input stream for the given input stream by copying the data to a temporary file.

Parameters:
  `input` - the input stream to be read. It will be closed by this method.
Throws:
  `IOException` - if something went wrong while creating the temporary file.

### Method Detail

#### getPosition

    public long getPosition()

Returns offset in file at which next byte would be read.

Specified by:
  `getPosition` in interface `RandomAccessRead`
Returns:
  offset of next byte which will be returned with next `RandomAccessRead.read()` (if no more bytes are left it returns a value >= length of source)

#### seek

    public void seek(long newOffset)
              throws IOException

Seeks to new position. If new position is outside of current page the new page is either taken from cache or read from file and added to cache.

Specified by:
  `seek` in interface `RandomAccessRead`
Parameters:
  `newOffset` - the position to seek to.
Throws:
  `IOException` - if something went wrong.

#### read

    public int read()
             throws IOException

Description copied from interface: `RandomAccessRead`
Read a single byte of data.

Specified by:
  `read` in interface `RandomAccessRead`
Specified by:
  `read` in class `InputStream`
Returns:
  The byte of data that is being read.
Throws:
  `IOException` - If there is an error while reading the data.

#### read

    public int read(byte[] b)
             throws IOException

Description copied from interface: `RandomAccessRead`
Read a buffer of data.

Specified by:
  `read` in interface `RandomAccessRead`
Overrides:
  `read` in class `InputStream`
Parameters:
  `b` - The buffer to write the data to.
Returns:
  The number of bytes that were actually read.
Throws:
  `IOException` - If there was an error while reading the data.

#### read

    public int read(byte[] b,
                    int off,
                    int len)
             throws IOException

Description copied from interface: `RandomAccessRead`
Read a buffer of data.

Specified by:
  `read` in interface `RandomAccessRead`
Overrides:
  `read` in class `InputStream`
Parameters:
  `b` - The buffer to write the data to.
  `off` - Offset into the buffer to start writing.
  `len` - The amount of data to attempt to read.
Returns:
  The number of bytes that were actually read.
Throws:
  `IOException` - If there was an error while reading the data.

#### available

    public int available()
                  throws IOException

Description copied from interface: `RandomAccessRead`
Returns an estimate of the number of bytes that can be read.

Specified by:
  `available` in interface `RandomAccessRead`
Overrides:
  `available` in class `InputStream`
Returns:
  the number of bytes that can be read
Throws:
  `IOException` - if this random access has been closed

#### skip

    public long skip(long n)
              throws IOException

Overrides:
  `skip` in class `InputStream`
Throws:
  `IOException`

#### length

    public long length()
                throws IOException

Description copied from interface: `RandomAccessRead`
The total number of bytes that are available.

Specified by:
  `length` in interface `RandomAccessRead`
Returns:
  The number of bytes available.
Throws:
  `IOException` - If there is an IO error while determining the length of the data stream.

#### close

    public void close()
               throws IOException

Specified by:
  `close` in interface `Closeable`
Specified by:
  `close` in interface `AutoCloseable`
Overrides:
  `close` in class `InputStream`
Throws:
  `IOException`

#### isClosed

    public boolean isClosed()

Description copied from interface: `RandomAccessRead`
Returns true if this stream has been closed.

Specified by:
  `isClosed` in interface `RandomAccessRead`

#### peek

    public int peek()
             throws IOException

Description copied from interface: `RandomAccessRead`
This will peek at the next byte.

Specified by:
  `peek` in interface `RandomAccessRead`
Returns:
  The next byte on the stream, leaving it as available to read.
Throws:
  `IOException` - If there is an error reading the next byte.

#### rewind

    public void rewind(int bytes)
                throws IOException

Description copied from interface: `RandomAccessRead`
Seek backwards the given number of bytes.

Specified by:
  `rewind` in interface `RandomAccessRead`
Parameters:
  `bytes` - the number of bytes to be seeked backwards
Throws:
  `IOException` - If there is an error while seeking

#### readFully

    public byte[] readFully(int length)
                     throws IOException

Description copied from interface: `RandomAccessRead`
Reads a given number of bytes.

Specified by:
  `readFully` in interface `RandomAccessRead`
Parameters:
  `length` - the number of bytes to be read
Returns:
  a byte array containing the bytes just read
Throws:
  `IOException` - if an I/O error occurs while reading data

#### isEOF

    public boolean isEOF()
                  throws IOException

Description copied from interface: `RandomAccessRead`
A simple test to see if we are at the end of the data.

Specified by:
  `isEOF` in interface `RandomAccessRead`
Returns:
  true if we are at the end of the data.
Throws:
  `IOException` - If there is an error reading the next byte.