1: /* DeflaterOutputStream.java - Output filter for compressing. 2: Copyright (C) 1999, 2000, 2001, 2004, 2005 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: 86: // System.err.println("DOS deflated " + len + " out of " + buf.length); 87: if (len <= 0) 88: break; 89: out.write(buf, 0, len); 90: } 91: 92: if (! def.needsInput()) 93: throw new InternalError("Can't deflate all input?"); 94: } 95: 96: /** 97: * Creates a new DeflaterOutputStream with a default Deflater and 98: * default buffer size. 99: * @param out the output stream where deflated output should be written. 100: */ 101: public DeflaterOutputStream(OutputStream out) 102: { 103: this(out, new Deflater(), 4096); 104: } 105: 106: /** 107: * Creates a new DeflaterOutputStream with the given Deflater and 108: * default buffer size. 109: * @param out the output stream where deflated output should be written. 110: * @param defl the underlying deflater. 111: */ 112: public DeflaterOutputStream(OutputStream out, Deflater defl) 113: { 114: this(out, defl, 4096); 115: } 116: 117: /** 118: * Creates a new DeflaterOutputStream with the given Deflater and 119: * buffer size. 120: * @param out the output stream where deflated output should be written. 121: * @param defl the underlying deflater. 122: * @param bufsize the buffer size. 123: * @exception IllegalArgumentException if bufsize isn't positive. 124: */ 125: public DeflaterOutputStream(OutputStream out, Deflater defl, int bufsize) 126: { 127: super(out); 128: if (bufsize <= 0) 129: throw new IllegalArgumentException("bufsize <= 0"); 130: buf = new byte[bufsize]; 131: def = defl; 132: } 133: 134: /** 135: * Flushes the stream by calling flush() on the deflater and then 136: * on the underlying stream. This ensures that all bytes are 137: * flushed. This function doesn't work in Sun's JDK, but only in 138: * jazzlib. 139: */ 140: public void flush() throws IOException 141: { 142: def.flush(); 143: deflate(); 144: out.flush(); 145: } 146: 147: /** 148: * Finishes the stream by calling finish() on the deflater. This 149: * was the only way to ensure that all bytes are flushed in Sun's 150: * JDK. 151: */ 152: public void finish() throws IOException 153: { 154: def.finish(); 155: while (! def.finished()) 156: { 157: int len = def.deflate(buf, 0, buf.length); 158: if (len <= 0) 159: break; 160: out.write(buf, 0, len); 161: } 162: if (! def.finished()) 163: throw new InternalError("Can't deflate all input?"); 164: out.flush(); 165: } 166: 167: /** 168: * Calls finish() and closes the stream. 169: */ 170: public void close() throws IOException 171: { 172: finish(); 173: out.close(); 174: } 175: 176: /** 177: * Writes a single byte to the compressed output stream. 178: * @param bval the byte value. 179: */ 180: public void write(int bval) throws IOException 181: { 182: byte[] b = new byte[1]; 183: b[0] = (byte) bval; 184: write(b, 0, 1); 185: } 186: 187: /** 188: * Writes a len bytes from an array to the compressed stream. 189: * @param buf the byte array. 190: * @param off the offset into the byte array where to start. 191: * @param len the number of bytes to write. 192: */ 193: public void write(byte[] buf, int off, int len) throws IOException 194: { 195: def.setInput(buf, off, len); 196: deflate(); 197: } 198: }