panda.io.stream.LimitedInputStream Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of panda-core Show documentation
Panda Core is the core module of Panda Framework, it contains commonly used utility classes similar to apache-commons.
There is a newer version: 1.8.0
package panda.io.stream;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

import panda.io.SizeLimitExceededException;

/**
 * An input stream, which limits its data size. This stream is used, if the content length is
 * unknown.
 */
public class LimitedInputStream extends FilterInputStream {

	/**
	 * The maximum size of an item, in bytes.
	 */
	private final long sizeMax;

	/**
	 * The current number of bytes.
	 */
	private long count;

	/**
	 * Creates a new instance.
	 * 
	 * @param inputStream The input stream, which shall be limited.
	 * @param pSizeMax The limit; no more than this number of bytes shall be returned by the source
	 *            stream.
	 */
	public LimitedInputStream(InputStream inputStream, long pSizeMax) {
		super(inputStream);
		sizeMax = pSizeMax;
	}

	/**
	 * Called to indicate, that the input streams limit has been exceeded.
	 * 
	 * @param pSizeMax The input streams limit, in bytes.
	 * @param pCount The actual number of bytes.
	 * @throws IOException The called method is expected to raise an IOException.
	 */
	protected void raiseError(long pSizeMax, long pCount) throws IOException {
		throw new SizeLimitExceededException("The input stream exceeds the limited size (" + pSizeMax + ")", pCount, pSizeMax);
	}

	/**
	 * Called to check, whether the input streams limit is reached.
	 * 
	 * @throws IOException The given limit is exceeded.
	 */
	private void checkLimit() throws IOException {
		if (count > sizeMax) {
			raiseError(sizeMax, count);
		}
	}

	/**
	 * Reads the next byte of data from this input stream. The value byte is returned as an
	 * int in the range 0 to 255. If no byte is available
	 * because the end of the stream has been reached, the value -1 is returned. This
	 * method blocks until input data is available, the end of the stream is detected, or an
	 * exception is thrown.
	 * 
	 * This method simply performs in.read() and returns the result.
	 * 
	 * @return the next byte of data, or -1 if the end of the stream is reached.
	 * @exception IOException if an I/O error occurs.
	 */
	@Override
	public int read() throws IOException {
		int res = super.read();
		if (res != -1) {
			count++;
			checkLimit();
		}
		return res;
	}

	/**
	 * Reads up to len bytes of data from this input stream into an array of bytes. If
	 * len is not zero, the method blocks until some input is available; otherwise, no
	 * bytes are read and 0 is returned.
	 * 
	 * This method simply performs in.read(b, off, len) and returns the result.
	 * 
	 * @param b the buffer into which the data is read.
	 * @param off The start offset in the destination array b.
	 * @param len the maximum number of bytes read.
	 * @return the total number of bytes read into the buffer, or -1 if there is no
	 *         more data because the end of the stream has been reached.
	 * @exception NullPointerException If b is null.
	 * @exception IndexOutOfBoundsException If off is negative, len is
	 *                negative, or len is greater than b.length - off
	 * @exception IOException if an I/O error occurs.
	 */
	@Override
	public int read(byte[] b, int off, int len) throws IOException {
		int res = super.read(b, off, len);
		if (res > 0) {
			count += res;
			checkLimit();
		}
		return res;
	}
}