Back to index...

	/*
	* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.util.zip;

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

	/**
	* Implements an input stream filter for compressing data in the "deflate"
	* compression format.
	*
	* @since 1.6
	* @author David R Tribble (david@tribble.com)
	*
	* @see DeflaterOutputStream
	* @see InflaterOutputStream
	* @see InflaterInputStream
	*/

	public class DeflaterInputStream extends FilterInputStream {
	/** Compressor for this stream. */
	protected final Deflater def;

	/** Input buffer for reading compressed data. */
	protected final byte[] buf;

	/** Temporary read buffer. */
	private byte[] rbuf = new byte[1];

	/** Default compressor is used. */
	private boolean usesDefaultDeflater = false;

	/** End of the underlying input stream has been reached. */
	private boolean reachEOF = false;

	/**
	* Check to make sure that this stream has not been closed.
	*/
	private void ensureOpen() throws IOException {
	if (in == null) {
	throw new IOException("Stream closed");
	}
	}

	/**
	* Creates a new input stream with a default compressor and buffer
	* size.
	*
	* @param in input stream to read the uncompressed data to
	* @throws NullPointerException if {@code in} is null
	*/
	public DeflaterInputStream(InputStream in) {
	this(in, new Deflater());
	usesDefaultDeflater = true;
	}

	/**
	* Creates a new input stream with the specified compressor and a
	* default buffer size.
	*
	* @param in input stream to read the uncompressed data to
	* @param defl compressor ("deflater") for this stream
	* @throws NullPointerException if {@code in} or {@code defl} is null
	*/
	public DeflaterInputStream(InputStream in, Deflater defl) {
	this(in, defl, 512);
	}

	/**
	* Creates a new input stream with the specified compressor and buffer
	* size.
	*
	* @param in input stream to read the uncompressed data to
	* @param defl compressor ("deflater") for this stream
	* @param bufLen compression buffer size
	* @throws IllegalArgumentException if {@code bufLen <= 0}
	* @throws NullPointerException if {@code in} or {@code defl} is null
	*/
	public DeflaterInputStream(InputStream in, Deflater defl, int bufLen) {
	super(in);

	// Sanity checks
	if (in == null)
	throw new NullPointerException("Null input");
	if (defl == null)
	throw new NullPointerException("Null deflater");
	if (bufLen < 1)
	throw new IllegalArgumentException("Buffer size < 1");

	// Initialize
	def = defl;
	buf = new byte[bufLen];
	}

	/**
	* Closes this input stream and its underlying input stream, discarding
	* any pending uncompressed data.
	*
	* @throws IOException if an I/O error occurs
	*/
	public void close() throws IOException {
	if (in != null) {
	try {
	// Clean up
	if (usesDefaultDeflater) {
	def.end();
	}

	in.close();
	} finally {
	in = null;
	}
	}
	}

	/**
	* Reads a single byte of compressed data from the input stream.
	* This method will block until some input can be read and compressed.
	*
	* @return a single byte of compressed data, or -1 if the end of the
	* uncompressed input stream is reached
	* @throws IOException if an I/O error occurs or if this stream is
	* already closed
	*/
	public int read() throws IOException {
	// Read a single byte of compressed data
	int len = read(rbuf, 0, 1);
	if (len <= 0)
	return -1;
	return (rbuf[0] & 0xFF);
	}

	/**
	* Reads compressed data into a byte array.
	* This method will block until some input can be read and compressed.
	*
	* @param b buffer into which the data is read
	* @param off starting offset of the data within {@code b}
	* @param len maximum number of compressed bytes to read into {@code b}
	* @return the actual number of bytes read, or -1 if the end of the
	* uncompressed input stream is reached
	* @throws IndexOutOfBoundsException if {@code len > b.length - off}
	* @throws IOException if an I/O error occurs or if this input stream is
	* already closed
	*/
	public int read(byte[] b, int off, int len) throws IOException {
	// Sanity checks
	ensureOpen();
	if (b == null) {
	throw new NullPointerException("Null buffer for read");
	} else if (off < 0 \|\| len < 0 \|\| len > b.length - off) {
	throw new IndexOutOfBoundsException();
	} else if (len == 0) {
	return 0;
	}

	// Read and compress (deflate) input data bytes
	int cnt = 0;
	while (len > 0 && !def.finished()) {
	int n;

	// Read data from the input stream
	if (def.needsInput()) {
	n = in.read(buf, 0, buf.length);
	if (n < 0) {
	// End of the input stream reached
	def.finish();
	} else if (n > 0) {
	def.setInput(buf, 0, n);
	}
	}

	// Compress the input data, filling the read buffer
	n = def.deflate(b, off, len);
	cnt += n;
	off += n;
	len -= n;
	}
	if (cnt == 0 && def.finished()) {
	reachEOF = true;
	cnt = -1;
	}

	return cnt;
	}

	/**
	* Skips over and discards data from the input stream.
	* This method may block until the specified number of bytes are read and
	* skipped. <em>Note:</em> While {@code n} is given as a {@code long},
	* the maximum number of bytes which can be skipped is
	* {@code Integer.MAX_VALUE}.
	*
	* @param n number of bytes to be skipped
	* @return the actual number of bytes skipped
	* @throws IOException if an I/O error occurs or if this stream is
	* already closed
	*/
	public long skip(long n) throws IOException {
	if (n < 0) {
	throw new IllegalArgumentException("negative skip length");
	}
	ensureOpen();

	// Skip bytes by repeatedly decompressing small blocks
	if (rbuf.length < 512)
	rbuf = new byte[512];

	int total = (int)Math.min(n, Integer.MAX_VALUE);
	long cnt = 0;
	while (total > 0) {
	// Read a small block of uncompressed bytes
	int len = read(rbuf, 0, (total <= rbuf.length ? total : rbuf.length));

	if (len < 0) {
	break;
	}
	cnt += len;
	total -= len;
	}
	return cnt;
	}

	/**
	* Returns 0 after EOF has been reached, otherwise always return 1.
	* <p>
	* Programs should not count on this method to return the actual number
	* of bytes that could be read without blocking
	* @return zero after the end of the underlying input stream has been
	* reached, otherwise always returns 1
	* @throws IOException if an I/O error occurs or if this stream is
	* already closed
	*/
	public int available() throws IOException {
	ensureOpen();
	if (reachEOF) {
	return 0;
	}
	return 1;
	}

	/**
	* Always returns {@code false} because this input stream does not support
	* the {@link #mark mark()} and {@link #reset reset()} methods.
	*
	* @return false, always
	*/
	public boolean markSupported() {
	return false;
	}

	/**
	* <i>This operation is not supported</i>.
	*
	* @param limit maximum bytes that can be read before invalidating the position marker
	*/
	public void mark(int limit) {
	// Operation not supported
	}

	/**
	* <i>This operation is not supported</i>.
	*
	* @throws IOException always thrown
	*/
	public void reset() throws IOException {
	throw new IOException("mark/reset not supported");
	}
	}

Back to index...