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
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.util.zip;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import libcore.io.Streams;
/**
* This class provides an implementation of {@code FilterOutputStream} that
* compresses data using the <i>DEFLATE</i> algorithm. Basically it wraps the
* {@code Deflater} class and takes care of the buffering.
*
* @see Deflater
*/
public class DeflaterOutputStream extends FilterOutputStream {
static final int BUF_SIZE = 512;
/**
* The buffer for the data to be written to.
*/
protected byte[] buf;
/**
* The deflater used.
*/
protected Deflater def;
boolean done = false;
private final boolean syncFlush;
/**
* This constructor lets you pass the {@code Deflater} specifying the
* compression algorithm.
*
* @param os
* is the {@code OutputStream} where to write the compressed data
* to.
* @param def
* is the specific {@code Deflater} that is used to compress
* data.
*/
public DeflaterOutputStream(OutputStream os, Deflater def) {
this(os, def, BUF_SIZE, false);
}
/**
* This is the most basic constructor. You only need to pass the {@code
* OutputStream} to which the compressed data shall be written to. The
* default settings for the {@code Deflater} and internal buffer are used.
* In particular the {@code Deflater} produces a ZLIB header in the output
* stream.
*
* @param os
* is the OutputStream where to write the compressed data to.
*/
public DeflaterOutputStream(OutputStream os) {
this(os, new Deflater(), BUF_SIZE, false);
}
/**
* This constructor lets you specify both the compression algorithm as well
* as the internal buffer size to be used.
*
* @param os
* is the {@code OutputStream} where to write the compressed data
* to.
* @param def
* is the specific {@code Deflater} that will be used to compress
* data.
* @param bsize
* is the size to be used for the internal buffer.
*/
public DeflaterOutputStream(OutputStream os, Deflater def, int bsize) {
this(os, def, bsize, false);
}
/**
* @hide
* @since 1.7
*/
public DeflaterOutputStream(OutputStream os, boolean syncFlush) {
this(os, new Deflater(), BUF_SIZE, syncFlush);
}
/**
* @hide
* @since 1.7
*/
public DeflaterOutputStream(OutputStream os, Deflater def, boolean syncFlush) {
this(os, def, BUF_SIZE, syncFlush);
}
/**
* @hide
* @since 1.7
*/
public DeflaterOutputStream(OutputStream os, Deflater def, int bsize, boolean syncFlush) {
super(os);
if (os == null || def == null) {
throw new NullPointerException();
}
if (bsize <= 0) {
throw new IllegalArgumentException();
}
this.def = def;
this.syncFlush = syncFlush;
buf = new byte[bsize];
}
/**
* Compress the data in the input buffer and write it to the underlying
* stream.
*
* @throws IOException
* If an error occurs during deflation.
*/
protected void deflate() throws IOException {
int byteCount;
while ((byteCount = def.deflate(buf)) != 0) {
out.write(buf, 0, byteCount);
}
}
/**
* Writes any unwritten compressed data to the underlying stream, the closes
* all underlying streams. This stream can no longer be used after close()
* has been called.
*
* @throws IOException
* If an error occurs while closing the data compression
* process.
*/
@Override
public void close() throws IOException {
// everything closed here should also be closed in ZipOutputStream.close()
if (!def.finished()) {
finish();
}
def.end();
out.close();
}
/**
* Writes any unwritten data to the underlying stream. Does not close the
* stream.
*
* @throws IOException
* If an error occurs.
*/
public void finish() throws IOException {
if (done) {
return;
}
def.finish();
while (!def.finished()) {
int byteCount = def.deflate(buf);
out.write(buf, 0, byteCount);
}
done = true;
}
@Override public void write(int i) throws IOException {
Streams.writeSingleByte(this, i);
}
/**
* Compresses {@code byteCount} bytes of data from {@code buf} starting at
* {@code offset} and writes it to the underlying stream.
* @throws IOException
* If an error occurs during writing.
*/
@Override public void write(byte[] buffer, int offset, int byteCount) throws IOException {
if (done) {
throw new IOException("attempt to write after finish");
}
Arrays.checkOffsetAndCount(buffer.length, offset, byteCount);
if (!def.needsInput()) {
throw new IOException();
}
def.setInput(buffer, offset, byteCount);
deflate();
}
/**
* Flushes the underlying stream. This flushes only the bytes that can be
* compressed at the highest level.
*
* <p>For deflater output streams constructed with Java 7's
* {@code syncFlush} parameter set to true (not yet available on Android),
* this first flushes all outstanding data so that it may be immediately
* read by its recipient. Doing so may degrade compression.
*/
@Override public void flush() throws IOException {
if (syncFlush) {
int byteCount;
while ((byteCount = def.deflate(buf, 0, buf.length, Deflater.SYNC_FLUSH)) != 0) {
out.write(buf, 0, byteCount);
}
}
out.flush();
}
}
|
