History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/util/zip/DeflaterInputStream.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/util/zip/DeflaterInputStream.java+294−0
@@ -0,0 +1,294 @@
1+/*
2+ * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package java.util.zip;
27+
28+import java.io.FilterInputStream;
29+import java.io.InputStream;
30+import java.io.IOException;
31+
32+/**
33+ * Implements an input stream filter for compressing data in the "deflate"
34+ * compression format.
35+ *
36+ * @since 1.6
37+ * @author David R Tribble (david@tribble.com)
38+ *
39+ * @see DeflaterOutputStream
40+ * @see InflaterOutputStream
41+ * @see InflaterInputStream
42+ */
43+
44+public class DeflaterInputStream extends FilterInputStream {
45+ /** Compressor for this stream. */
46+ protected final Deflater def;
47+
48+ /** Input buffer for reading compressed data. */
49+ protected final byte[] buf;
50+
51+ /** Temporary read buffer. */
52+ private byte[] rbuf = new byte[1];
53+
54+ /** Default compressor is used. */
55+ private boolean usesDefaultDeflater = false;
56+
57+ /** End of the underlying input stream has been reached. */
58+ private boolean reachEOF = false;
59+
60+ /**
61+ * Check to make sure that this stream has not been closed.
62+ */
63+ private void ensureOpen() throws IOException {
64+ if (in == null) {
65+ throw new IOException("Stream closed");
66+ }
67+ }
68+
69+ /**
70+ * Creates a new input stream with a default compressor and buffer
71+ * size.
72+ *
73+ * @param in input stream to read the uncompressed data to
74+ * @throws NullPointerException if {@code in} is null
75+ */
76+ public DeflaterInputStream(InputStream in) {
77+ this(in, new Deflater());
78+ usesDefaultDeflater = true;
79+ }
80+
81+ /**
82+ * Creates a new input stream with the specified compressor and a
83+ * default buffer size.
84+ *
85+ * @param in input stream to read the uncompressed data to
86+ * @param defl compressor ("deflater") for this stream
87+ * @throws NullPointerException if {@code in} or {@code defl} is null
88+ */
89+ public DeflaterInputStream(InputStream in, Deflater defl) {
90+ this(in, defl, 512);
91+ }
92+
93+ /**
94+ * Creates a new input stream with the specified compressor and buffer
95+ * size.
96+ *
97+ * @param in input stream to read the uncompressed data to
98+ * @param defl compressor ("deflater") for this stream
99+ * @param bufLen compression buffer size
100+ * @throws IllegalArgumentException if {@code bufLen} is <= 0
101+ * @throws NullPointerException if {@code in} or {@code defl} is null
102+ */
103+ public DeflaterInputStream(InputStream in, Deflater defl, int bufLen) {
104+ super(in);
105+
106+ // Sanity checks
107+ if (in == null)
108+ throw new NullPointerException("Null input");
109+ if (defl == null)
110+ throw new NullPointerException("Null deflater");
111+ if (bufLen < 1)
112+ throw new IllegalArgumentException("Buffer size < 1");
113+
114+ // Initialize
115+ def = defl;
116+ buf = new byte[bufLen];
117+ }
118+
119+ /**
120+ * Closes this input stream and its underlying input stream, discarding
121+ * any pending uncompressed data.
122+ *
123+ * @throws IOException if an I/O error occurs
124+ */
125+ public void close() throws IOException {
126+ if (in != null) {
127+ try {
128+ // Clean up
129+ if (usesDefaultDeflater) {
130+ def.end();
131+ }
132+
133+ in.close();
134+ } finally {
135+ in = null;
136+ }
137+ }
138+ }
139+
140+ /**
141+ * Reads a single byte of compressed data from the input stream.
142+ * This method will block until some input can be read and compressed.
143+ *
144+ * @return a single byte of compressed data, or -1 if the end of the
145+ * uncompressed input stream is reached
146+ * @throws IOException if an I/O error occurs or if this stream is
147+ * already closed
148+ */
149+ public int read() throws IOException {
150+ // Read a single byte of compressed data
151+ int len = read(rbuf, 0, 1);
152+ if (len <= 0)
153+ return -1;
154+ return (rbuf[0] & 0xFF);
155+ }
156+
157+ /**
158+ * Reads compressed data into a byte array.
159+ * This method will block until some input can be read and compressed.
160+ *
161+ * @param b buffer into which the data is read
162+ * @param off starting offset of the data within {@code b}
163+ * @param len maximum number of compressed bytes to read into {@code b}
164+ * @return the actual number of bytes read, or -1 if the end of the
165+ * uncompressed input stream is reached
166+ * @throws IndexOutOfBoundsException if {@code len} > {@code b.length -
167+ * off}
168+ * @throws IOException if an I/O error occurs or if this input stream is
169+ * already closed
170+ */
171+ public int read(byte[] b, int off, int len) throws IOException {
172+ // Sanity checks
173+ ensureOpen();
174+ if (b == null) {
175+ throw new NullPointerException("Null buffer for read");
176+ } else if (off < 0 || len < 0 || len > b.length - off) {
177+ throw new IndexOutOfBoundsException();
178+ } else if (len == 0) {
179+ return 0;
180+ }
181+
182+ // Read and compress (deflate) input data bytes
183+ int cnt = 0;
184+ while (len > 0 && !def.finished()) {
185+ int n;
186+
187+ // Read data from the input stream
188+ if (def.needsInput()) {
189+ n = in.read(buf, 0, buf.length);
190+ if (n < 0) {
191+ // End of the input stream reached
192+ def.finish();
193+ } else if (n > 0) {
194+ def.setInput(buf, 0, n);
195+ }
196+ }
197+
198+ // Compress the input data, filling the read buffer
199+ n = def.deflate(b, off, len);
200+ cnt += n;
201+ off += n;
202+ len -= n;
203+ }
204+ if (cnt == 0 && def.finished()) {
205+ reachEOF = true;
206+ cnt = -1;
207+ }
208+
209+ return cnt;
210+ }
211+
212+ /**
213+ * Skips over and discards data from the input stream.
214+ * This method may block until the specified number of bytes are read and
215+ * skipped. <em>Note:</em> While {@code n} is given as a {@code long},
216+ * the maximum number of bytes which can be skipped is
217+ * {@code Integer.MAX_VALUE}.
218+ *
219+ * @param n number of bytes to be skipped
220+ * @return the actual number of bytes skipped
221+ * @throws IOException if an I/O error occurs or if this stream is
222+ * already closed
223+ */
224+ public long skip(long n) throws IOException {
225+ if (n < 0) {
226+ throw new IllegalArgumentException("negative skip length");
227+ }
228+ ensureOpen();
229+
230+ // Skip bytes by repeatedly decompressing small blocks
231+ if (rbuf.length < 512)
232+ rbuf = new byte[512];
233+
234+ int total = (int)Math.min(n, Integer.MAX_VALUE);
235+ long cnt = 0;
236+ while (total > 0) {
237+ // Read a small block of uncompressed bytes
238+ int len = read(rbuf, 0, (total <= rbuf.length ? total : rbuf.length));
239+
240+ if (len < 0) {
241+ break;
242+ }
243+ cnt += len;
244+ total -= len;
245+ }
246+ return cnt;
247+ }
248+
249+ /**
250+ * Returns 0 after EOF has been reached, otherwise always return 1.
251+ * <p>
252+ * Programs should not count on this method to return the actual number
253+ * of bytes that could be read without blocking
254+ * @return zero after the end of the underlying input stream has been
255+ * reached, otherwise always returns 1
256+ * @throws IOException if an I/O error occurs or if this stream is
257+ * already closed
258+ */
259+ public int available() throws IOException {
260+ ensureOpen();
261+ if (reachEOF) {
262+ return 0;
263+ }
264+ return 1;
265+ }
266+
267+ /**
268+ * Always returns {@code false} because this input stream does not support
269+ * the {@link #mark mark()} and {@link #reset reset()} methods.
270+ *
271+ * @return false, always
272+ */
273+ public boolean markSupported() {
274+ return false;
275+ }
276+
277+ /**
278+ * <i>This operation is not supported</i>.
279+ *
280+ * @param limit maximum bytes that can be read before invalidating the position marker
281+ */
282+ public void mark(int limit) {
283+ // Operation not supported
284+ }
285+
286+ /**
287+ * <i>This operation is not supported</i>.
288+ *
289+ * @throws IOException always thrown
290+ */
291+ public void reset() throws IOException {
292+ throw new IOException("mark/reset not supported");
293+ }
294+}