java.util.zip.InflaterOutputStream Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jtransc-rt Show documentation
JVM AOT compiler currently generating JavaScript, C++, Haxe, with initial focus on Kotlin and games.
The newest version!
/*
 * 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();
        }
    }
}