Frames | No Frames |
1: /* DeflaterOutputStream.java - Output filter for compressing. 2: Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.util.zip; 40: 41: import java.io.FilterOutputStream; 42: import java.io.IOException; 43: import java.io.OutputStream; 44: 45: /* Written using on-line Java Platform 1.2 API Specification 46: * and JCL book. 47: * Believed complete and correct. 48: */ 49: 50: /** 51: * This is a special FilterOutputStream deflating the bytes that are 52: * written through it. It uses the Deflater for deflating. 53: * 54: * A special thing to be noted is that flush() doesn't flush 55: * everything in Sun's JDK, but it does so in jazzlib. This is because 56: * Sun's Deflater doesn't have a way to flush() everything, without 57: * finishing the stream. 58: * 59: * @author Tom Tromey, Jochen Hoenicke 60: * @date Jan 11, 2001 61: */ 62: public class DeflaterOutputStream extends FilterOutputStream 63: { 64: /** 65: * This buffer is used temporarily to retrieve the bytes from the 66: * deflater and write them to the underlying output stream. 67: */ 68: protected byte[] buf; 69: 70: /** 71: * The deflater which is used to deflate the stream. 72: */ 73: protected Deflater def; 74: 75: /** 76: * Deflates everything in the def's input buffers. This will call 77: * <code>def.deflate()</code> until all bytes from the input buffers 78: * are processed. 79: */ 80: protected void deflate() throws IOException 81: { 82: while (! def.needsInput()) 83: { 84: int len = def.deflate(buf, 0, buf.length); 85: if (len > 0) 86: out.write(buf, 0, len); 87: } 88: } 89: 90: /** 91: * Creates a new DeflaterOutputStream with a default Deflater and 92: * default buffer size. 93: * @param out the output stream where deflated output should be written. 94: */ 95: public DeflaterOutputStream(OutputStream out) 96: { 97: this(out, new Deflater(), 512); 98: } 99: 100: /** 101: * Creates a new DeflaterOutputStream with the given Deflater and 102: * default buffer size. 103: * @param out the output stream where deflated output should be written. 104: * @param defl the underlying deflater. 105: */ 106: public DeflaterOutputStream(OutputStream out, Deflater defl) 107: { 108: this(out, defl, 512); 109: } 110: 111: /** 112: * Creates a new DeflaterOutputStream with the given Deflater and 113: * buffer size. 114: * @param out the output stream where deflated output should be written. 115: * @param defl the underlying deflater. 116: * @param bufsize the buffer size. 117: * @exception IllegalArgumentException if bufsize isn't positive. 118: */ 119: public DeflaterOutputStream(OutputStream out, Deflater defl, int bufsize) 120: { 121: super(out); 122: if (bufsize <= 0) 123: throw new IllegalArgumentException("bufsize <= 0"); 124: buf = new byte[bufsize]; 125: def = defl; 126: } 127: 128: /** 129: * Finishes the stream by calling finish() on the deflater. This 130: * was the only way to ensure that all bytes are flushed in Sun's 131: * JDK. 132: */ 133: public void finish() throws IOException 134: { 135: inbufWrite(); 136: def.finish(); 137: while (! def.finished()) 138: { 139: int len = def.deflate(buf, 0, buf.length); 140: if (len > 0) 141: out.write(buf, 0, len); 142: } 143: } 144: 145: /** 146: * Calls finish() and closes the stream. 147: */ 148: public void close() throws IOException 149: { 150: finish(); 151: out.close(); 152: } 153: 154: /** 155: * Writes a single byte to the compressed output stream. 156: * @param bval the byte value. 157: */ 158: public void write(int bval) throws IOException 159: { 160: if (inbuf == null) 161: inbuf = new byte[128]; 162: else if (inbufLength == inbuf.length) 163: inbufWrite(); 164: inbuf[inbufLength++] = (byte) bval; 165: } 166: 167: /** 168: * Writes a len bytes from an array to the compressed stream. 169: * @param buf the byte array. 170: * @param off the offset into the byte array where to start. 171: * @param len the number of bytes to write. 172: */ 173: public void write(byte[] buf, int off, int len) throws IOException 174: { 175: inbufWrite(); 176: def.setInput(buf, off, len); 177: deflate(); 178: } 179: 180: private void inbufWrite() throws IOException 181: { 182: if (inbufLength > 0) 183: { 184: int size = inbufLength; 185: inbufLength = 0; 186: write(inbuf, 0, size); 187: } 188: } 189: 190: // Used, if needed, for write(int). 191: private byte[] inbuf; 192: // Used length of inbuf. 193: private int inbufLength; 194: }