FileDocCategorySizeDatePackage
InflaterInputStream.javaAPI DocJava SE 6 API8138Tue Jun 10 00:26:00 BST 2008java.util.zip

InflaterInputStream

public class InflaterInputStream extends FilterInputStream
This class implements a stream filter for uncompressing data in the "deflate" compression format. It is also used as the basis for other decompression filters, such as GZIPInputStream.
see
Inflater
version
1.40, 04/07/06
author
David Connelly

Fields Summary
protected Inflater
inf
Decompressor for this stream.
protected byte[]
buf
Input buffer for decompression.
protected int
len
Length of input buffer.
private boolean
closed
private boolean
reachEOF
boolean
usesDefaultInflater
private byte[]
singleByteBuf
private byte[]
b
Constructors Summary
public InflaterInputStream(InputStream in, Inflater inf, int size)
Creates a new input stream with the specified decompressor and buffer size.

param
in the input stream
param
inf the decompressor ("inflater")
param
size the input buffer size
exception
IllegalArgumentException if size is <= 0

	super(in);
        if (in == null || inf == null) {
            throw new NullPointerException();
        } else if (size <= 0) {
            throw new IllegalArgumentException("buffer size <= 0");
        }
	this.inf = inf;
	buf = new byte[size];
    
public InflaterInputStream(InputStream in, Inflater inf)
Creates a new input stream with the specified decompressor and a default buffer size.

param
in the input stream
param
inf the decompressor ("inflater")

	this(in, inf, 512);
    
public InflaterInputStream(InputStream in)
Creates a new input stream with a default decompressor and buffer size.

param
in the input stream


                          
       
	this(in, new Inflater());
        usesDefaultInflater = true;
    
Methods Summary
public intavailable()
Returns 0 after EOF has been reached, otherwise always return 1.

Programs should not count on this method to return the actual number of bytes that could be read without blocking.

return
1 before EOF and 0 after EOF.
exception
IOException if an I/O error occurs.

        ensureOpen();
        if (reachEOF) {
            return 0;
        } else {
            return 1;
        }
    
public voidclose()
Closes this input stream and releases any system resources associated with the stream.

exception
IOException if an I/O error has occurred

        if (!closed) {
            if (usesDefaultInflater)
                inf.end();
	    in.close();
            closed = true;
        }
    
private voidensureOpen()
Check to make sure that this stream has not been closed

    
                    
         
	if (closed) {
	    throw new IOException("Stream closed");
        }
    
protected voidfill()
Fills input buffer with more data to decompress.

exception
IOException if an I/O error has occurred

	ensureOpen();
	len = in.read(buf, 0, buf.length);
	if (len == -1) {
	    throw new EOFException("Unexpected end of ZLIB input stream");
	}
	inf.setInput(buf, 0, len);
    
public synchronized voidmark(int readlimit)
Marks the current position in this input stream.

The mark method of InflaterInputStream does nothing.

param
readlimit the maximum limit of bytes that can be read before the mark position becomes invalid.
see
java.io.InputStream#reset()

    
public booleanmarkSupported()
Tests if this input stream supports the mark and reset methods. The markSupported method of InflaterInputStream returns false.

return
a boolean indicating if this stream type supports the mark and reset methods.
see
java.io.InputStream#mark(int)
see
java.io.InputStream#reset()

        return false;
    
public intread()
Reads a byte of uncompressed data. This method will block until enough input is available for decompression.

return
the byte read, or -1 if end of compressed input is reached
exception
IOException if an I/O error has occurred


                                               
         
	ensureOpen();
	return read(singleByteBuf, 0, 1) == -1 ? -1 : singleByteBuf[0] & 0xff;
    
public intread(byte[] b, int off, int len)
Reads uncompressed data into an array of bytes. If len is not zero, the method will block until some input can be decompressed; otherwise, no bytes are read and 0 is returned.

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 actual number of bytes read, or -1 if the end of the compressed input is reached or a preset dictionary is needed
exception
NullPointerException If b is null.
exception
IndexOutOfBoundsException If off is negative, len is negative, or len is greater than b.length - off
exception
ZipException if a ZIP format error has occurred
exception
IOException if an I/O error has occurred

	ensureOpen();
	if (b == null) {
	    throw new NullPointerException();
	} else if (off < 0 || len < 0 || len > b.length - off) {
	    throw new IndexOutOfBoundsException();
	} else if (len == 0) {
	    return 0;
	}
	try {
	    int n;
	    while ((n = inf.inflate(b, off, len)) == 0) {
		if (inf.finished() || inf.needsDictionary()) {
                    reachEOF = true;
		    return -1;
		}
		if (inf.needsInput()) {
		    fill();
		}
	    }
	    return n;
	} catch (DataFormatException e) {
	    String s = e.getMessage();
	    throw new ZipException(s != null ? s : "Invalid ZLIB data format");
	}
    
public synchronized voidreset()
Repositions this stream to the position at the time the mark method was last called on this input stream.

The method reset for class InflaterInputStream does nothing except throw an IOException.

exception
IOException if this method is invoked.
see
java.io.InputStream#mark(int)
see
java.io.IOException

        throw new IOException("mark/reset not supported");
    
public longskip(long n)
Skips specified number of bytes of uncompressed data.

param
n the number of bytes to skip
return
the actual number of bytes skipped.
exception
IOException if an I/O error has occurred
exception
IllegalArgumentException if n < 0


                                              
          
        if (n < 0) {
            throw new IllegalArgumentException("negative skip length");
        }
	ensureOpen();
	int max = (int)Math.min(n, Integer.MAX_VALUE);
	int total = 0;
	while (total < max) {
	    int len = max - total;
	    if (len > b.length) {
		len = b.length;
	    }
	    len = read(b, 0, len);
	    if (len == -1) {
                reachEOF = true;
		break;
	    }
	    total += len;
	}
	return total;