jdk/src/java.base/share/classes/java/util/zip/Deflater.java
author avstepan
Thu, 06 Aug 2015 19:07:35 +0300
changeset 32037 ab4526f4ac10
parent 25859 3317bb8137f4
child 32649 2ee9017c7597
permissions -rw-r--r--
8133115: docs: replace <tt> tags (obsolete in html5) for java.util.logging, java.util.prefs, java.util.zip, java.util.jar Reviewed-by: lancea
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
18560
75e936782d6b 8019228: Fix doclint issues in java.util.zip
darcy
parents: 14342
diff changeset
     2
 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5469
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5469
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5469
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5469
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5469
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.util.zip;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
 * This class provides support for general purpose compression using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
 * popular ZLIB compression library. The ZLIB compression library was
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
 * initially developed as part of the PNG graphics standard and is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
 * protected by patents. It is fully described in the specifications at
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
 * the <a href="package-summary.html#package_description">java.util.zip
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
 * package description</a>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
 * <p>The following code fragment demonstrates a trivial compression
32037
ab4526f4ac10 8133115: docs: replace <tt> tags (obsolete in html5) for java.util.logging, java.util.prefs, java.util.zip, java.util.jar
avstepan
parents: 25859
diff changeset
    37
 * and decompression of a string using {@code Deflater} and
ab4526f4ac10 8133115: docs: replace <tt> tags (obsolete in html5) for java.util.logging, java.util.prefs, java.util.zip, java.util.jar
avstepan
parents: 25859
diff changeset
    38
 * {@code Inflater}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * <blockquote><pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 *     // Encode a String into bytes
5469
18ea05ea56b9 6937842: Unreadable \uXXXX in javadoc
martin
parents: 5194
diff changeset
    43
 *     String inputString = "blahblahblah";
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 *     byte[] input = inputString.getBytes("UTF-8");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 *     // Compress the bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 *     byte[] output = new byte[100];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 *     Deflater compresser = new Deflater();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 *     compresser.setInput(input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 *     compresser.finish();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 *     int compressedDataLength = compresser.deflate(output);
2940
c6fe11c24d43 6808625: Incomplete code sample in Deflater javadoc
sherman
parents: 2
diff changeset
    52
 *     compresser.end();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 *     // Decompress the bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
 *     Inflater decompresser = new Inflater();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
 *     decompresser.setInput(output, 0, compressedDataLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
 *     byte[] result = new byte[100];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
 *     int resultLength = decompresser.inflate(result);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
 *     decompresser.end();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 *     // Decode the bytes into a String
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
 *     String outputString = new String(result, 0, resultLength, "UTF-8");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
 * } catch(java.io.UnsupportedEncodingException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 *     // handle
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
 * } catch (java.util.zip.DataFormatException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
 *     // handle
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
 * }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
 * </pre></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
 * @see         Inflater
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
 * @author      David Connelly
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
public
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
class Deflater {
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
    75
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
    76
    private final ZStreamRef zsRef;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
    private byte[] buf = new byte[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
    private int off, len;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
    private int level, strategy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
    private boolean setParams;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
    private boolean finish, finished;
13409
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
    82
    private long bytesRead;
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
    83
    private long bytesWritten;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
     * Compression method for the deflate algorithm (the only one currently
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * supported).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
    public static final int DEFLATED = 8;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     * Compression level for no compression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
    public static final int NO_COMPRESSION = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
     * Compression level for fastest compression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
    public static final int BEST_SPEED = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
     * Compression level for best compression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
    public static final int BEST_COMPRESSION = 9;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
     * Default compression level.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
    public static final int DEFAULT_COMPRESSION = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
     * Compression strategy best used for data consisting mostly of small
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
     * values with a somewhat random distribution. Forces more Huffman coding
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
     * and less string matching.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
    public static final int FILTERED = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
     * Compression strategy for Huffman coding only.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
    public static final int HUFFMAN_ONLY = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
     * Default compression strategy.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
    public static final int DEFAULT_STRATEGY = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   128
    /**
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   129
     * Compression flush mode used to achieve best compression result.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   130
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   131
     * @see Deflater#deflate(byte[], int, int, int)
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   132
     * @since 1.7
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   133
     */
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   134
    public static final int NO_FLUSH = 0;
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   135
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   136
    /**
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   137
     * Compression flush mode used to flush out all pending output; may
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   138
     * degrade compression for some compression algorithms.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   139
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   140
     * @see Deflater#deflate(byte[], int, int, int)
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   141
     * @since 1.7
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   142
     */
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   143
    public static final int SYNC_FLUSH = 2;
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   144
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   145
    /**
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   146
     * Compression flush mode used to flush out all pending output and
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   147
     * reset the deflater. Using this mode too often can seriously degrade
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   148
     * compression.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   149
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   150
     * @see Deflater#deflate(byte[], int, int, int)
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   151
     * @since 1.7
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   152
     */
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   153
    public static final int FULL_FLUSH = 3;
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   154
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
        /* Zip library is loaded from System.initializeSystemClass */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
        initIDs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
     * Creates a new compressor using the specified compression level.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
     * If 'nowrap' is true then the ZLIB header and checksum fields will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
     * not be used in order to support the compression format used in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
     * both GZIP and PKZIP.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
     * @param level the compression level (0-9)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
     * @param nowrap if true then use GZIP compatible compression
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
    public Deflater(int level, boolean nowrap) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
        this.level = level;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
        this.strategy = DEFAULT_STRATEGY;
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   171
        this.zsRef = new ZStreamRef(init(level, DEFAULT_STRATEGY, nowrap));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     * Creates a new compressor using the specified compression level.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     * Compressed data will be generated in ZLIB format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
     * @param level the compression level (0-9)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
    public Deflater(int level) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
        this(level, false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
     * Creates a new compressor with the default compression level.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     * Compressed data will be generated in ZLIB format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
    public Deflater() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
        this(DEFAULT_COMPRESSION, false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
     * Sets input data for compression. This should be called whenever
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
     * needsInput() returns true indicating that more input data is required.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
     * @param b the input data bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
     * @param off the start offset of the data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
     * @param len the length of the data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
     * @see Deflater#needsInput
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   199
    public void setInput(byte[] b, int off, int len) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
        if (b== null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        if (off < 0 || len < 0 || off > b.length - len) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
            throw new ArrayIndexOutOfBoundsException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
        }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   206
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   207
            this.buf = b;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   208
            this.off = off;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   209
            this.len = len;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   210
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
     * Sets input data for compression. This should be called whenever
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
     * needsInput() returns true indicating that more input data is required.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
     * @param b the input data bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
     * @see Deflater#needsInput
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
    public void setInput(byte[] b) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
        setInput(b, 0, b.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
     * Sets preset dictionary for compression. A preset dictionary is used
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
     * when the history buffer can be predetermined. When the data is later
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
     * uncompressed with Inflater.inflate(), Inflater.getAdler() can be called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
     * in order to get the Adler-32 value of the dictionary required for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
     * decompression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
     * @param b the dictionary data bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
     * @param off the start offset of the data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
     * @param len the length of the data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
     * @see Inflater#inflate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
     * @see Inflater#getAdler
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   235
    public void setDictionary(byte[] b, int off, int len) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   236
        if (b == null) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
        if (off < 0 || len < 0 || off > b.length - len) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
            throw new ArrayIndexOutOfBoundsException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
        }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   242
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   243
            ensureOpen();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   244
            setDictionary(zsRef.address(), b, off, len);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   245
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
     * Sets preset dictionary for compression. A preset dictionary is used
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
     * when the history buffer can be predetermined. When the data is later
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
     * uncompressed with Inflater.inflate(), Inflater.getAdler() can be called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
     * in order to get the Adler-32 value of the dictionary required for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
     * decompression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
     * @param b the dictionary data bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
     * @see Inflater#inflate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     * @see Inflater#getAdler
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
    public void setDictionary(byte[] b) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
        setDictionary(b, 0, b.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     * Sets the compression strategy to the specified value.
19865
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   264
     *
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   265
     * <p> If the compression strategy is changed, the next invocation
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   266
     * of {@code deflate} will compress the input available so far with
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   267
     * the old strategy (and may be flushed); the new strategy will take
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   268
     * effect only after that invocation.
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   269
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
     * @param strategy the new compression strategy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
     * @exception IllegalArgumentException if the compression strategy is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
     *                                     invalid
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   274
    public void setStrategy(int strategy) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
        switch (strategy) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
          case DEFAULT_STRATEGY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
          case FILTERED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
          case HUFFMAN_ONLY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
          default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
            throw new IllegalArgumentException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
        }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   283
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   284
            if (this.strategy != strategy) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   285
                this.strategy = strategy;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   286
                setParams = true;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   287
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
    /**
19865
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   292
     * Sets the compression level to the specified value.
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   293
     *
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   294
     * <p> If the compression level is changed, the next invocation
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   295
     * of {@code deflate} will compress the input available so far
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   296
     * with the old level (and may be flushed); the new level will
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   297
     * take effect only after that invocation.
b68185846a71 8020687: Deflater.setLevel does not work as expected
sherman
parents: 18560
diff changeset
   298
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
     * @param level the new compression level (0-9)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
     * @exception IllegalArgumentException if the compression level is invalid
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   302
    public void setLevel(int level) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
        if ((level < 0 || level > 9) && level != DEFAULT_COMPRESSION) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
            throw new IllegalArgumentException("invalid compression level");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
        }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   306
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   307
            if (this.level != level) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   308
                this.level = level;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   309
                setParams = true;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   310
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
     * Returns true if the input data buffer is empty and setInput()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
     * should be called in order to provide more input.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     * @return true if the input data buffer is empty and setInput()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
     * should be called in order to provide more input
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
    public boolean needsInput() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
        return len <= 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
     * When called, indicates that compression should end with the current
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
     * contents of the input buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   328
    public void finish() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   329
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   330
            finish = true;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   331
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
     * Returns true if the end of the compressed data output stream has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
     * been reached.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
     * @return true if the end of the compressed data output stream has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
     * been reached
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   340
    public boolean finished() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   341
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   342
            return finished;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   343
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
    /**
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   347
     * Compresses the input data and fills specified buffer with compressed
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   348
     * data. Returns actual number of bytes of compressed data. A return value
4354
3a70dde80b3b 6905029: Broken links in Deflater and DeflaterOutputStream javadoc
martin
parents: 4178
diff changeset
   349
     * of 0 indicates that {@link #needsInput() needsInput} should be called
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   350
     * in order to determine if more input data is required.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   351
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   352
     * <p>This method uses {@link #NO_FLUSH} as its compression flush mode.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   353
     * An invocation of this method of the form {@code deflater.deflate(b, off, len)}
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   354
     * yields the same result as the invocation of
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   355
     * {@code deflater.deflate(b, off, len, Deflater.NO_FLUSH)}.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   356
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
     * @param b the buffer for the compressed data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
     * @param off the start offset of the data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
     * @param len the maximum number of bytes of compressed data
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   360
     * @return the actual number of bytes of compressed data written to the
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   361
     *         output buffer
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   362
     */
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   363
    public int deflate(byte[] b, int off, int len) {
4178
61284fdd478f 6894950: test/java/util/zip/Bounds.java fails with OoutOfMemoryError
sherman
parents: 4162
diff changeset
   364
        return deflate(b, off, len, NO_FLUSH);
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   365
    }
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   366
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   367
    /**
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   368
     * Compresses the input data and fills specified buffer with compressed
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   369
     * data. Returns actual number of bytes of compressed data. A return value
4354
3a70dde80b3b 6905029: Broken links in Deflater and DeflaterOutputStream javadoc
martin
parents: 4178
diff changeset
   370
     * of 0 indicates that {@link #needsInput() needsInput} should be called
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   371
     * in order to determine if more input data is required.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   372
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   373
     * <p>This method uses {@link #NO_FLUSH} as its compression flush mode.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   374
     * An invocation of this method of the form {@code deflater.deflate(b)}
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   375
     * yields the same result as the invocation of
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   376
     * {@code deflater.deflate(b, 0, b.length, Deflater.NO_FLUSH)}.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   377
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   378
     * @param b the buffer for the compressed data
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   379
     * @return the actual number of bytes of compressed data written to the
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   380
     *         output buffer
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
     */
4162
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   382
    public int deflate(byte[] b) {
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   383
        return deflate(b, 0, b.length, NO_FLUSH);
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   384
    }
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   385
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   386
    /**
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   387
     * Compresses the input data and fills the specified buffer with compressed
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   388
     * data. Returns actual number of bytes of data compressed.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   389
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   390
     * <p>Compression flush mode is one of the following three modes:
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   391
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   392
     * <ul>
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   393
     * <li>{@link #NO_FLUSH}: allows the deflater to decide how much data
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   394
     * to accumulate, before producing output, in order to achieve the best
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   395
     * compression (should be used in normal use scenario). A return value
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   396
     * of 0 in this flush mode indicates that {@link #needsInput()} should
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   397
     * be called in order to determine if more input data is required.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   398
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   399
     * <li>{@link #SYNC_FLUSH}: all pending output in the deflater is flushed,
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   400
     * to the specified output buffer, so that an inflater that works on
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   401
     * compressed data can get all input data available so far (In particular
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   402
     * the {@link #needsInput()} returns {@code true} after this invocation
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   403
     * if enough output space is provided). Flushing with {@link #SYNC_FLUSH}
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   404
     * may degrade compression for some compression algorithms and so it
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   405
     * should be used only when necessary.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   406
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   407
     * <li>{@link #FULL_FLUSH}: all pending output is flushed out as with
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   408
     * {@link #SYNC_FLUSH}. The compression state is reset so that the inflater
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   409
     * that works on the compressed output data can restart from this point
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   410
     * if previous compressed data has been damaged or if random access is
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   411
     * desired. Using {@link #FULL_FLUSH} too often can seriously degrade
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   412
     * compression.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   413
     * </ul>
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   414
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   415
     * <p>In the case of {@link #FULL_FLUSH} or {@link #SYNC_FLUSH}, if
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   416
     * the return value is {@code len}, the space available in output
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   417
     * buffer {@code b}, this method should be invoked again with the same
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   418
     * {@code flush} parameter and more output space.
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   419
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   420
     * @param b the buffer for the compressed data
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   421
     * @param off the start offset of the data
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   422
     * @param len the maximum number of bytes of compressed data
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   423
     * @param flush the compression flush mode
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   424
     * @return the actual number of bytes of compressed data written to
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   425
     *         the output buffer
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   426
     *
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   427
     * @throws IllegalArgumentException if the flush mode is invalid
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   428
     * @since 1.7
425328b81201 4206909: want java.util.zip to work for interactive use (Z_SYNC_FLUSH)
sherman
parents: 2940
diff changeset
   429
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   430
    public int deflate(byte[] b, int off, int len, int flush) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
        if (b == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
        if (off < 0 || len < 0 || off > b.length - len) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
            throw new ArrayIndexOutOfBoundsException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
        }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   437
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   438
            ensureOpen();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   439
            if (flush == NO_FLUSH || flush == SYNC_FLUSH ||
13409
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   440
                flush == FULL_FLUSH) {
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   441
                int thisLen = this.len;
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   442
                int n = deflateBytes(zsRef.address(), b, off, len, flush);
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   443
                bytesWritten += n;
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   444
                bytesRead += (thisLen - this.len);
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   445
                return n;
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   446
            }
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   447
            throw new IllegalArgumentException();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   448
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
     * Returns the ADLER-32 value of the uncompressed data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
     * @return the ADLER-32 value of the uncompressed data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   455
    public int getAdler() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   456
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   457
            ensureOpen();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   458
            return getAdler(zsRef.address());
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   459
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
     * Returns the total number of uncompressed bytes input so far.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
     * <p>Since the number of bytes may be greater than
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
     * Integer.MAX_VALUE, the {@link #getBytesRead()} method is now
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
     * the preferred means of obtaining this information.</p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
     * @return the total number of uncompressed bytes input so far
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
    public int getTotalIn() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
        return (int) getBytesRead();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
    /**
18560
75e936782d6b 8019228: Fix doclint issues in java.util.zip
darcy
parents: 14342
diff changeset
   476
     * Returns the total number of uncompressed bytes input so far.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
     * @return the total (non-negative) number of uncompressed bytes input so far
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   481
    public long getBytesRead() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   482
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   483
            ensureOpen();
13409
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   484
            return bytesRead;
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   485
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
     * Returns the total number of compressed bytes output so far.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
     * <p>Since the number of bytes may be greater than
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
     * Integer.MAX_VALUE, the {@link #getBytesWritten()} method is now
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
     * the preferred means of obtaining this information.</p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
     * @return the total number of compressed bytes output so far
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
    public int getTotalOut() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
        return (int) getBytesWritten();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
    /**
18560
75e936782d6b 8019228: Fix doclint issues in java.util.zip
darcy
parents: 14342
diff changeset
   502
     * Returns the total number of compressed bytes output so far.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
     * @return the total (non-negative) number of compressed bytes output so far
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   507
    public long getBytesWritten() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   508
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   509
            ensureOpen();
13409
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   510
            return bytesWritten;
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   511
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
     * Resets deflater so that a new set of input data can be processed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
     * Keeps current compression level and strategy settings.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   518
    public void reset() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   519
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   520
            ensureOpen();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   521
            reset(zsRef.address());
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   522
            finish = false;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   523
            finished = false;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   524
            off = len = 0;
13409
fe3ab27ef1a6 7188852: Move implementation of De/Inflater.getBytesRead/Writtten() to java from native
sherman
parents: 7668
diff changeset
   525
            bytesRead = bytesWritten = 0;
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   526
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
     * Closes the compressor and discards any unprocessed input.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
     * This method should be called when the compressor is no longer
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
     * being used, but will also be called automatically by the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
     * finalize() method. Once this method is called, the behavior
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
     * of the Deflater object is undefined.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
     */
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   536
    public void end() {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   537
        synchronized (zsRef) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   538
            long addr = zsRef.address();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   539
            zsRef.clear();
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   540
            if (addr != 0) {
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   541
                end(addr);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   542
                buf = null;
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   543
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
     * Closes the compressor when garbage is collected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
    protected void finalize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
        end();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
    private void ensureOpen() {
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   555
        assert Thread.holdsLock(zsRef);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   556
        if (zsRef.address() == 0)
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   557
            throw new NullPointerException("Deflater has been closed");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
    private static native void initIDs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
    private native static long init(int level, int strategy, boolean nowrap);
5173
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   562
    private native static void setDictionary(long addr, byte[] b, int off, int len);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   563
    private native int deflateBytes(long addr, byte[] b, int off, int len,
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   564
                                    int flush);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   565
    private native static int getAdler(long addr);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   566
    private native static void reset(long addr);
36ad2c5fbb51 6745393: Inflater/Deflater clone issue
sherman
parents: 4178
diff changeset
   567
    private native static void end(long addr);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
}