org.apache.commons.io.input

## Class UnsynchronizedFilterInputStream

- java.lang.Object
- - java.io.InputStream
  - - org.apache.commons.io.input.UnsynchronizedFilterInputStream

- All Implemented Interfaces:
    Closeable, AutoCloseable
  Direct Known Subclasses:
    UnsynchronizedBufferedInputStream

      public class UnsynchronizedFilterInputStream
      extends InputStream

  An unsynchronized version of `FilterInputStream`, not thread-safe.

  Wraps an existing `InputStream` and performs some transformation on the input data while it is being read. Transformations can be anything from a simple byte-wise filtering input data to an on-the-fly compression or decompression of the underlying stream. Input streams that wrap another input stream and provide some additional functionality on top of it usually inherit from this class.

  Provenance: Apache Harmony and modified.

  Since:
    2.12.0
  See Also:
    `FilterInputStream`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `UnsynchronizedFilterInputStream.Builder` Builds a new `UnsynchronizedFilterInputStream` instance.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected InputStream` | `inputStream` The source input stream that is filtered.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `available()` Returns the number of bytes that are available before this stream will block.
    `static UnsynchronizedFilterInputStream.Builder` | `builder()` Constructs a new `UnsynchronizedFilterInputStream.Builder`.
    `void` | `close()` Closes this stream.
    `void` | `mark(int readlimit)` Sets a mark position in this stream.
    `boolean` | `markSupported()` Indicates whether this stream supports `mark()` and `reset()`.
    `int` | `read()` Reads a single byte from the filtered stream and returns it as an integer in the range from 0 to 255.
    `int` | `read(byte[] buffer)` Reads bytes from this stream and stores them in the byte array `buffer`.
    `int` | `read(byte[] buffer, int offset, int count)` Reads at most `count` bytes from this stream and stores them in the byte array `buffer` starting at `offset`.
    `void` | `reset()` Resets this stream to the last marked location.
    `long` | `skip(long count)` Skips `count` number of bytes in this stream.

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

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

- - ### Field Detail

    - #### inputStream

          protected volatile InputStream inputStream

      The source input stream that is filtered.

  - ### Method Detail

    - #### builder

          public static UnsynchronizedFilterInputStream.Builder builder()

      Constructs a new `UnsynchronizedFilterInputStream.Builder`.
      Returns:
        a new `UnsynchronizedFilterInputStream.Builder`.

    - #### available

          public int available()
                        throws IOException

      Returns the number of bytes that are available before this stream will block.
      Overrides:
        `available` in class `InputStream`
      Returns:
        the number of bytes available before blocking.
      Throws:
        `IOException` - if an error occurs in this stream.

    - #### close

          public void close()
                     throws IOException

      Closes this stream. This implementation closes the filtered stream.
      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Overrides:
        `close` in class `InputStream`
      Throws:
        `IOException` - if an error occurs while closing this stream.

    - #### mark

          public void mark(int readlimit)

      Sets a mark position in this stream. The parameter `readlimit` indicates how many bytes can be read before the mark is invalidated. Sending `reset()` will reposition this stream back to the marked position, provided that `readlimit` has not been surpassed.

      This implementation sets a mark in the filtered stream.

      Overrides:
        `mark` in class `InputStream`
      Parameters:
        `readlimit` - the number of bytes that can be read from this stream before the mark is invalidated.
      See Also:
        `markSupported()`, `reset()`

    - #### markSupported

          public boolean markSupported()

      Indicates whether this stream supports `mark()` and `reset()`. This implementation returns whether or not the filtered stream supports marking.
      Overrides:
        `markSupported` in class `InputStream`
      Returns:
        `true` if `mark()` and `reset()` are supported, `false` otherwise.
      See Also:
        `mark(int)`, `reset()`, `skip(long)`

    - #### read

          public int read()
                   throws IOException

      Reads a single byte from the filtered stream and returns it as an integer in the range from 0 to 255. Returns -1 if the end of this stream has been reached.
      Specified by:
        `read` in class `InputStream`
      Returns:
        the byte read or -1 if the end of the filtered stream has been reached.
      Throws:
        `IOException` - if the stream is closed or another IOException occurs.

    - #### read

          public int read(byte[] buffer)
                   throws IOException

      Reads bytes from this stream and stores them in the byte array `buffer`. Returns the number of bytes actually read or -1 if no bytes were read and the end of this stream was encountered. This implementation reads bytes from the filtered stream.
      Overrides:
        `read` in class `InputStream`
      Parameters:
        `buffer` - the byte array in which to store the read bytes.
      Returns:
        the number of bytes actually read or -1 if the end of the filtered stream has been reached while reading.
      Throws:
        `IOException` - if this stream is closed or another IOException occurs.

    - #### read

          public int read(byte[] buffer,
                          int offset,
                          int count)
                   throws IOException

      Reads at most `count` bytes from this stream and stores them in the byte array `buffer` starting at `offset`. Returns the number of bytes actually read or -1 if no bytes have been read and the end of this stream has been reached. This implementation reads bytes from the filtered stream.
      Overrides:
        `read` in class `InputStream`
      Parameters:
        `buffer` - the byte array in which to store the bytes read.
        `offset` - the initial position in `buffer` to store the bytes read from this stream.
        `count` - the maximum number of bytes to store in `buffer`.
      Returns:
        the number of bytes actually read or -1 if the end of the filtered stream has been reached while reading.
      Throws:
        `IOException` - if this stream is closed or another I/O error occurs.

    - #### reset

          public void reset()
                     throws IOException

      Resets this stream to the last marked location. This implementation resets the target stream.
      Overrides:
        `reset` in class `InputStream`
      Throws:
        `IOException` - if this stream is already closed, no mark has been set or the mark is no longer valid because more than `readlimit` bytes have been read since setting the mark.
      See Also:
        `mark(int)`, `markSupported()`

    - #### skip

          public long skip(long count)
                    throws IOException

      Skips `count` number of bytes in this stream. Subsequent `read()`'s will not return these bytes unless `reset()` is used. This implementation skips `count` number of bytes in the filtered stream.
      Overrides:
        `skip` in class `InputStream`
      Parameters:
        `count` - the number of bytes to skip.
      Returns:
        the number of bytes actually skipped.
      Throws:
        `IOException` - if this stream is closed or another IOException occurs.
      See Also:
        `mark(int)`, `reset()`

Copyright © 2002–2023 The Apache Software Foundation. All rights reserved.