--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/classes/java/util/zip/DeflaterInputStream.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,293 @@
+/*
+ * 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");
+ }
+}