InputStream
* and simply redirects calls made to it to the subordinate InputStream
* instead. Subclasses of this class perform additional filtering
* functions in addition to simply redirecting the call.
*
* This class is not abstract. However, since it only redirects calls
* to a subordinate InputStream without adding any functionality
* on top of it, this class should not be used directly. Instead, various
* subclasses of this class should be used. This is enforced with a
* protected constructor. Do not try to hack around it.
*
* When creating a subclass of FilterInputStream, override the
* appropriate methods to implement the desired filtering. However, note
* that the read(byte[]) method does not need to be overridden
* as this class redirects calls to that method to
* read(byte[], int, int) instead of to the subordinate
* InputStream read(byte[]) method.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy (warrenl@cygnus.com)
*/
public class FilterInputStream extends InputStream
{
/**
* This is the subordinate InputStream to which method calls
* are redirected
*/
protected InputStream in;
/**
* Create a FilterInputStream with the specified subordinate
* InputStream.
*
* @param in The subordinate InputStream
*/
protected FilterInputStream(InputStream in)
{
this.in = in;
}
/**
* Calls the in.mark(int) method.
*
* @param readlimit The parameter passed to in.mark(int)
*/
public void mark(int readlimit)
{
in.mark(readlimit);
}
/**
* Calls the in.markSupported() method.
*
* @return true if mark/reset is supported, false
* otherwise
*/
public boolean markSupported()
{
return in.markSupported();
}
/**
* Calls the in.reset() method.
*
* @exception IOException If an error occurs
*/
public void reset() throws IOException
{
in.reset();
}
/**
* Calls the in.available() method.
*
* @return The value returned from in.available()
*
* @exception IOException If an error occurs
*/
public int available() throws IOException
{
return in.available();
}
/**
* Calls the in.skip(long) method
*
* @param numBytes The requested number of bytes to skip.
*
* @return The value returned from in.skip(long)
*
* @exception IOException If an error occurs
*/
public long skip(long numBytes) throws IOException
{
return in.skip(numBytes);
}
/**
* Calls the in.read() method
*
* @return The value returned from in.read()
*
* @exception IOException If an error occurs
*/
public int read() throws IOException
{
return in.read();
}
/**
* Calls the read(byte[], int, int) overloaded method.
* Note that
* this method does not redirect its call directly to a corresponding
* method in in. This allows subclasses to override only the
* three argument version of read.
*
* @param buf The buffer to read bytes into
*
* @return The value retured from in.read(byte[], int, int)
*
* @exception IOException If an error occurs
*/
public int read(byte[] buf) throws IOException
{
return read(buf, 0, buf.length);
}
/**
* Calls the in.read(byte[], int, int) method.
*
* @param buf The buffer to read bytes into
* @param offset The index into the buffer to start storing bytes
* @param len The maximum number of bytes to read.
*
* @return The value retured from in.read(byte[], int, int)
*
* @exception IOException If an error occurs
*/
public int read(byte[] buf, int offset, int len) throws IOException
{
return in.read(buf, offset, len);
}
/**
* This method closes the input stream by closing the input stream that
* this object is filtering. Future attempts to access this stream may
* throw an exception.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
in.close();
}
}