| Frames | No Frames |
1: /* FilterInputStream.java -- Base class for classes that filter input 2: Copyright (C) 1998, 1999, 2001, 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.io; 40: 41: /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 42: * "The Java Language Specification", ISBN 0-201-63451-1 43: * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. 44: * Status: Believed complete and correct. 45: */ 46: 47: /** 48: * This is the common superclass of all standard classes that filter 49: * input. It acts as a layer on top of an underlying <code>InputStream</code> 50: * and simply redirects calls made to it to the subordinate InputStream 51: * instead. Subclasses of this class perform additional filtering 52: * functions in addition to simply redirecting the call. 53: * <p> 54: * This class is not abstract. However, since it only redirects calls 55: * to a subordinate <code>InputStream</code> without adding any functionality 56: * on top of it, this class should not be used directly. Instead, various 57: * subclasses of this class should be used. This is enforced with a 58: * protected constructor. Do not try to hack around it. 59: * <p> 60: * When creating a subclass of <code>FilterInputStream</code>, override the 61: * appropriate methods to implement the desired filtering. However, note 62: * that the <code>read(byte[])</code> method does not need to be overridden 63: * as this class redirects calls to that method to 64: * <code>read(byte[], int, int)</code> instead of to the subordinate 65: * <code>InputStream read(byte[])</code> method. 66: * 67: * @author Aaron M. Renn (arenn@urbanophile.com) 68: * @author Warren Levy (warrenl@cygnus.com) 69: */ 70: public class FilterInputStream extends InputStream 71: { 72: /** 73: * This is the subordinate <code>InputStream</code> to which method calls 74: * are redirected 75: */ 76: protected InputStream in; 77: 78: /** 79: * Create a <code>FilterInputStream</code> with the specified subordinate 80: * <code>InputStream</code>. 81: * 82: * @param in The subordinate <code>InputStream</code> 83: */ 84: protected FilterInputStream(InputStream in) 85: { 86: this.in = in; 87: } 88: 89: /** 90: * Calls the <code>in.mark(int)</code> method. 91: * 92: * @param readlimit The parameter passed to <code>in.mark(int)</code> 93: */ 94: public void mark(int readlimit) 95: { 96: in.mark(readlimit); 97: } 98: 99: /** 100: * Calls the <code>in.markSupported()</code> method. 101: * 102: * @return <code>true</code> if mark/reset is supported, <code>false</code> 103: * otherwise 104: */ 105: public boolean markSupported() 106: { 107: return in.markSupported(); 108: } 109: 110: /** 111: * Calls the <code>in.reset()</code> method. 112: * 113: * @exception IOException If an error occurs 114: */ 115: public void reset() throws IOException 116: { 117: in.reset(); 118: } 119: 120: /** 121: * Calls the <code>in.available()</code> method. 122: * 123: * @return The value returned from <code>in.available()</code> 124: * 125: * @exception IOException If an error occurs 126: */ 127: public int available() throws IOException 128: { 129: return in.available(); 130: } 131: 132: /** 133: * Calls the <code>in.skip(long)</code> method 134: * 135: * @param numBytes The requested number of bytes to skip. 136: * 137: * @return The value returned from <code>in.skip(long)</code> 138: * 139: * @exception IOException If an error occurs 140: */ 141: public long skip(long numBytes) throws IOException 142: { 143: return in.skip(numBytes); 144: } 145: 146: /** 147: * Calls the <code>in.read()</code> method 148: * 149: * @return The value returned from <code>in.read()</code> 150: * 151: * @exception IOException If an error occurs 152: */ 153: public int read() throws IOException 154: { 155: return in.read(); 156: } 157: 158: /** 159: * Calls the <code>read(byte[], int, int)</code> overloaded method. 160: * Note that 161: * this method does not redirect its call directly to a corresponding 162: * method in <code>in</code>. This allows subclasses to override only the 163: * three argument version of <code>read</code>. 164: * 165: * @param buf The buffer to read bytes into 166: * 167: * @return The value retured from <code>in.read(byte[], int, int)</code> 168: * 169: * @exception IOException If an error occurs 170: */ 171: public int read(byte[] buf) throws IOException 172: { 173: return read(buf, 0, buf.length); 174: } 175: 176: /** 177: * Calls the <code>in.read(byte[], int, int)</code> method. 178: * 179: * @param buf The buffer to read bytes into 180: * @param offset The index into the buffer to start storing bytes 181: * @param len The maximum number of bytes to read. 182: * 183: * @return The value retured from <code>in.read(byte[], int, int)</code> 184: * 185: * @exception IOException If an error occurs 186: */ 187: public int read(byte[] buf, int offset, int len) throws IOException 188: { 189: return in.read(buf, offset, len); 190: } 191: 192: /** 193: * This method closes the input stream by closing the input stream that 194: * this object is filtering. Future attempts to access this stream may 195: * throw an exception. 196: * 197: * @exception IOException If an error occurs 198: */ 199: public void close() throws IOException 200: { 201: in.close(); 202: } 203: }