Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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;
/**
* An {@code OutputStream} filter to decompress data. Callers write
* compressed data in the "deflate" format, and uncompressed data is
* written to the underlying stream.
* @since 1.6
*/
public class InflaterOutputStream extends FilterOutputStream {
private static final int DEFAULT_BUFFER_SIZE = 1024;
protected final Inflater inf;
protected final byte[] buf;
private boolean closed = false;
/**
* Constructs an {@code InflaterOutputStream} with a new {@code Inflater} and an
* implementation-defined default internal buffer size. {@code out} is a destination
* for uncompressed data, and compressed data will be written to this stream.
*
* @param out the destination {@code OutputStream}
*/
public InflaterOutputStream(OutputStream out) {
this(out, new Inflater());
}
/**
* Constructs an {@code InflaterOutputStream} with the given {@code Inflater} and an
* implementation-defined default internal buffer size. {@code out} is a destination
* for uncompressed data, and compressed data will be written to this stream.
*
* @param out the destination {@code OutputStream}
* @param inf the {@code Inflater} to be used for decompression
*/
public InflaterOutputStream(OutputStream out, Inflater inf) {
this(out, inf, DEFAULT_BUFFER_SIZE);
}
/**
* Constructs an {@code InflaterOutputStream} with the given {@code Inflater} and
* given internal buffer size. {@code out} is a destination
* for uncompressed data, and compressed data will be written to this stream.
*
* @param out the destination {@code OutputStream}
* @param inf the {@code Inflater} to be used for decompression
* @param bufferSize the length in bytes of the internal buffer
*/
public InflaterOutputStream(OutputStream out, Inflater inf, int bufferSize) {
super(out);
if (out == null) {
throw new NullPointerException("out == null");
} else if (inf == null) {
throw new NullPointerException("inf == null");
}
if (bufferSize <= 0) {
throw new IllegalArgumentException("bufferSize <= 0: " + bufferSize);
}
this.inf = inf;
this.buf = new byte[bufferSize];
}
/**
* Writes remaining data into the output stream and closes the underlying
* output stream.
*/
@Override
public void close() throws IOException {
if (!closed) {
finish();
inf.end();
out.close();
closed = true;
}
}
@Override
public void flush() throws IOException {
finish();
out.flush();
}
/**
* Finishes writing current uncompressed data into the InflaterOutputStream
* without closing it.
*
* @throws IOException if an I/O error occurs, or the stream has been closed
*/
public void finish() throws IOException {
checkClosed();
write();
}
/**
* Writes a byte to the decompressing output stream. {@code b} should be a byte of
* compressed input. The corresponding uncompressed data will be written to the underlying
* stream.
*
* @param b the byte
* @throws IOException if an I/O error occurs, or the stream has been closed
* @throws ZipException if a zip exception occurs.
*/
@Override
public void write(int b) throws IOException, ZipException {
write(new byte[] { (byte) b }, 0, 1);
}
/**
* Writes to the decompressing output stream. The {@code bytes} array should contain
* compressed input. The corresponding uncompressed data will be written to the underlying
* stream.
*
* @throws IOException if an I/O error occurs, or the stream has been closed
* @throws ZipException if a zip exception occurs.
* @throws NullPointerException if {@code b == null}.
* @throws IndexOutOfBoundsException if {@code off < 0 || len < 0 || off + len > b.length}
*/
@Override
public void write(byte[] bytes, int offset, int byteCount) throws IOException, ZipException {
checkClosed();
Arrays.checkOffsetAndCount(bytes.length, offset, byteCount);
inf.setInput(bytes, offset, byteCount);
write();
}
private void write() throws IOException, ZipException {
try {
int inflated;
while ((inflated = inf.inflate(buf)) > 0) {
out.write(buf, 0, inflated);
}
} catch (DataFormatException e) {
throw new ZipException();
}
}
private void checkClosed() throws IOException {
if (closed) {
throw new IOException();
}
}
}
