BoundedInputStream (Commons IO 2.5)
Date: 2016-12-01

org.apache.commons.io.input

## Class BoundedInputStream

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

- All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable

      public class BoundedInputStream
      extends java.io.InputStream

  This is a stream that will only supply bytes up to a certain length - if its position goes above that, it will stop.

  This is useful to wrap ServletInputStreams. The ServletInputStream will block if you try to read content from it that isn't there, because it doesn't know whether the content hasn't arrived yet or whether the content has finished. So, one of these, initialized with the Content-length sent in the ServletInputStream's header, will stop it blocking, providing it's been sent with a correct content length.

  Since:
    2.0
  Version:
    $Id: BoundedInputStream.java 1586342 2014-04-10 15:36:29Z ggregory $

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private java.io.InputStream` | `in` the wrapped input stream
    `private long` | `mark` the marked position
    `private long` | `max` the max length to provide
    `private long` | `pos` the number of bytes already returned
    `private boolean` | `propagateClose` flag if close shoud be propagated

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BoundedInputStream(java.io.InputStream in)` Creates a new `BoundedInputStream` that wraps the given input stream and is unlimited.
    `BoundedInputStream(java.io.InputStream in, long size)` Creates a new `BoundedInputStream` that wraps the given input stream and limits it to a certain size.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `available()`
    `void` | `close()` Invokes the delegate's `close()` method if `isPropagateClose()` is `true`.
    `boolean` | `isPropagateClose()` Indicates whether the `close()` method should propagate to the underling `InputStream`.
    `void` | `mark(int readlimit)` Invokes the delegate's `mark(int)` method.
    `boolean` | `markSupported()` Invokes the delegate's `markSupported()` method.
    `int` | `read()` Invokes the delegate's `read()` method if the current position is less than the limit.
    `int` | `read(byte[] b)` Invokes the delegate's `read(byte[])` method.
    `int` | `read(byte[] b, int off, int len)` Invokes the delegate's `read(byte[], int, int)` method.
    `void` | `reset()` Invokes the delegate's `reset()` method.
    `void` | `setPropagateClose(boolean propagateClose)` Set whether the `close()` method should propagate to the underling `InputStream`.
    `long` | `skip(long n)` Invokes the delegate's `skip(long)` method.
    `java.lang.String` | `toString()` Invokes the delegate's `toString()` method.

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

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

- - ### Field Detail

    - #### in

          private final java.io.InputStream in

      the wrapped input stream

    - #### max

          private final long max

      the max length to provide

    - #### pos

          private long pos

      the number of bytes already returned

    - #### mark

          private long mark

      the marked position

    - #### propagateClose

          private boolean propagateClose

      flag if close shoud be propagated

  - ### Constructor Detail

    - #### BoundedInputStream

          public BoundedInputStream(java.io.InputStream in,
                            long size)

      Creates a new `BoundedInputStream` that wraps the given input stream and limits it to a certain size.
      Parameters:
        `in` - The wrapped input stream
        `size` - The maximum number of bytes to return

    - #### BoundedInputStream

          public BoundedInputStream(java.io.InputStream in)

      Creates a new `BoundedInputStream` that wraps the given input stream and is unlimited.
      Parameters:
        `in` - The wrapped input stream

  - ### Method Detail

    - #### read

          public int read()
                   throws java.io.IOException

      Invokes the delegate's `read()` method if the current position is less than the limit.
      Specified by:
        `read` in class `java.io.InputStream`
      Returns:
        the byte read or -1 if the end of stream or the limit has been reached.
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### read

          public int read(byte[] b)
                   throws java.io.IOException

      Invokes the delegate's `read(byte[])` method.
      Overrides:
        `read` in class `java.io.InputStream`
      Parameters:
        `b` - the buffer to read the bytes into
      Returns:
        the number of bytes read or -1 if the end of stream or the limit has been reached.
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### read

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

      Invokes the delegate's `read(byte[], int, int)` method.
      Overrides:
        `read` in class `java.io.InputStream`
      Parameters:
        `b` - the buffer to read the bytes into
        `off` - The start offset
        `len` - The number of bytes to read
      Returns:
        the number of bytes read or -1 if the end of stream or the limit has been reached.
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### skip

          public long skip(long n)
                    throws java.io.IOException

      Invokes the delegate's `skip(long)` method.
      Overrides:
        `skip` in class `java.io.InputStream`
      Parameters:
        `n` - the number of bytes to skip
      Returns:
        the actual number of bytes skipped
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### available

          public int available()
                        throws java.io.IOException

      Overrides:
        `available` in class `java.io.InputStream`
      Throws:
        `java.io.IOException`

    - #### toString

          public java.lang.String toString()

      Invokes the delegate's `toString()` method.
      Overrides:
        `toString` in class `java.lang.Object`
      Returns:
        the delegate's `toString()`

    - #### close

          public void close()
                     throws java.io.IOException

      Invokes the delegate's `close()` method if `isPropagateClose()` is `true`.
      Specified by:
        `close` in interface `java.io.Closeable`
      Specified by:
        `close` in interface `java.lang.AutoCloseable`
      Overrides:
        `close` in class `java.io.InputStream`
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### reset

          public void reset()
                     throws java.io.IOException

      Invokes the delegate's `reset()` method.
      Overrides:
        `reset` in class `java.io.InputStream`
      Throws:
        `java.io.IOException` - if an I/O error occurs

    - #### mark

          public void mark(int readlimit)

      Invokes the delegate's `mark(int)` method.
      Overrides:
        `mark` in class `java.io.InputStream`
      Parameters:
        `readlimit` - read ahead limit

    - #### markSupported

          public boolean markSupported()

      Invokes the delegate's `markSupported()` method.
      Overrides:
        `markSupported` in class `java.io.InputStream`
      Returns:
        true if mark is supported, otherwise false

    - #### isPropagateClose

          public boolean isPropagateClose()

      Indicates whether the `close()` method should propagate to the underling `InputStream`.
      Returns:
        `true` if calling `close()` propagates to the `close()` method of the underlying stream or `false` if it does not.

    - #### setPropagateClose

          public void setPropagateClose(boolean propagateClose)

      Set whether the `close()` method should propagate to the underling `InputStream`.
      Parameters:
        `propagateClose` - `true` if calling `close()` propagates to the `close()` method of the underlying stream or `false` if it does not.

Copyright (c) 2002-2016 Apache Software Foundation