org.apache.pdfbox.io

## Class NonSeekableRandomAccessReadInputStream

- java.lang.Object
- - org.apache.pdfbox.io.NonSeekableRandomAccessReadInputStream

All Implemented Interfaces:
  Closeable, AutoCloseable, RandomAccessRead

    public class NonSeekableRandomAccessReadInputStream
    extends Object
    implements RandomAccessRead

An implementation of the RandomAccessRead interface using an InputStream as source. It is optimized for a minimal memory footprint by using a small buffer to read from the input stream instead of copying the whole input stream to memory. This reduces the random access read abilities, so that peek/rewind operations are limited to the data within the buffer. This class is meant to be used by consumers which process the data more or less in a serial manner and therefore don't need full random access.

### Field Summary

Fields
`protected int` `currentBufferPointer`
`protected long` `position`
`protected long` `size`

### Constructor Summary

Constructors
Constructor and Description
`NonSeekableRandomAccessReadInputStream(InputStream inputStream)` Default constructor.

### Method Summary

All Methods Instance Methods Concrete Methods
`int` `available()` Returns an estimate of the number of bytes that can be read (or skipped over) from the underlying input stream without blocking, which may be 0, or 0 when end of stream is detected.
`protected void` `checkClosed()` Ensure that the RandomAccessBuffer is not closed
`void` `close()`
`RandomAccessReadView` `createView(long startPosition, long streamLength)` Creates a random access read view starting at the given position with the given length.
`long` `getPosition()` Returns offset of next byte to be returned by a read method.
`boolean` `isClosed()` Returns true if this source 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` `read()` Read a single byte of data.
`int` `read(byte[] b, int offset, int length)` Read a buffer of data.
`void` `readFully(byte[] b, int offset, int length)` Same as `RandomAccessRead.read(byte[], int, int)` but will loop until exactly length bytes are read or it will throw an exception.
`void` `rewind(int bytes)` Seek backwards the given number of bytes.
`void` `seek(long position)` Seek to a position in the data.
`void` `skip(int length)` Skips a given number of bytes.

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

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

### Methods inherited from interface org.apache.pdfbox.io.RandomAccessRead

`peek, read, readFully`

### Field Detail

#### position

    protected long position

#### currentBufferPointer

    protected int currentBufferPointer

#### size

    protected long size

### Constructor Detail

#### NonSeekableRandomAccessReadInputStream

    public NonSeekableRandomAccessReadInputStream(InputStream inputStream)

Default constructor.

### Method Detail

#### close

    public void close()
               throws IOException

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

#### seek

    public void seek(long position)
              throws IOException

Seek to a position in the data.

Specified by:
  `seek` in interface `RandomAccessRead`
Parameters:
  `position` - The position to seek to.
Throws:
  `IOException` - If there is an error while seeking.

#### skip

    public void skip(int length)
              throws IOException

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

Specified by:
  `skip` in interface `RandomAccessRead`
Parameters:
  `length` - the number of bytes to be skipped
Throws:
  `IOException` - if an I/O error occurs while reading data

#### getPosition

    public long getPosition()
                     throws IOException

Returns offset of next byte to be returned by a read method.

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)
Throws:
  `IOException` - If there was an error while getting the current position

#### read

    public int read()
             throws IOException

Read a single byte of data.

Specified by:
  `read` in interface `RandomAccessRead`
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,
                    int offset,
                    int length)
             throws IOException

Read a buffer of data.

Specified by:
  `read` in interface `RandomAccessRead`
Parameters:
  `b` - The buffer to write the data to.
  `offset` - Offset into the buffer to start writing.
  `length` - 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.

#### readFully

    public void readFully(byte[] b,
                          int offset,
                          int length)
                   throws IOException

Description copied from interface: `RandomAccessRead`
Same as `RandomAccessRead.read(byte[], int, int)` but will loop until exactly length bytes are read or it will throw an exception.

Specified by:
  `readFully` in interface `RandomAccessRead`
Parameters:
  `b` - The buffer to write the data to.
  `offset` - Offset into the buffer to start writing.
  `length` - The exact amount of data to attempt to read.
Throws:
  `IOException`

#### available

    public int available()
                  throws IOException

Returns an estimate of the number of bytes that can be read (or skipped over) from the underlying input stream without blocking, which may be 0, or 0 when end of stream is detected.

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

#### length

    public long length()
                throws IOException

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.

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

#### checkClosed

    protected void checkClosed()
                        throws IOException

Ensure that the RandomAccessBuffer is not closed

Throws:
  `IOException` - If RandomAccessBuffer already closed

#### isClosed

    public boolean isClosed()

Returns true if this source has been closed.

Specified by:
  `isClosed` in interface `RandomAccessRead`
Returns:
  true if the source has been closed

#### isEOF

    public boolean isEOF()
                  throws IOException

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.

#### createView

    public RandomAccessReadView createView(long startPosition,
                                           long streamLength)
                                    throws IOException

Description copied from interface: `RandomAccessRead`
Creates a random access read view starting at the given position with the given length.

Specified by:
  `createView` in interface `RandomAccessRead`
Parameters:
  `startPosition` - start position within the underlying random access read
  `streamLength` - stream length
Returns:
  the random access read view
Throws:
  `IOException` - if something went wrong when creating the view for the RandomAccessRead