1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
/* * @(#)DeflaterInputStream.java 1.1 06/01/30 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ 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. * * @version 1.1 * @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} is <= 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} > {@code 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"); } }