Java IO.pdf - Nguyen Dang Binh

}
public int available() throws IOException {
return buf.length - index;
}
public long skip(long bytesToSkip) throws IOException {
}
long bytesSkipped = 0;
for (; bytesSkipped < bytesToSkip; bytesSkipped++) {
int c = this.read();
if (c == -1) break;
}
return bytesSkipped;
public synchronized void mark(int readlimit) {}
public synchronized void reset() throws IOException {
throw new IOException("marking not supported");
}
public boolean markSupported() {
return false;
}
Java I/O
The FilterInputStream class tacitly assumes that the number of bytes of input read from
the underlying stream is the same as the number of bytes read from the filter stream. That's
not always true, as is the case here. For instance, the HexFilter will provide three bytes of
data for every byte read from the underlying stream. The DecimalFilter will provide four.
Therefore, we also have to override skip() and available(). The skip() method simply
reads as many bytes as possible, then returns. The available() method simply returns the
number of bytes remaining in the buffer. For the uses we're putting these classes to, these
methods aren't all that important, so I haven't bothered to provide optimal implementations.
You can do better in subclasses, if you like.
The same problem applies to the mark() and reset() methods. These will mark and reset the
underlying stream, but what's really desired is to mark and reset this stream. The easiest
solution here is to deliberately not support marking and resetting. Subclasses can override this
if it seems important, or you can simply chain this stream to a buffered stream. However, the
buffered stream must follow the dump filter in the chain rather than precede it.
Concrete subclasses need only to implement a constructor or two and fill(). Example 6.10
shows the DecimalFilter class. Example 6.11 shows the HexFilter class. These two
classes are very similar. Each implements fill() and overrides available() (the latter
mainly because it's straightforward to do). The algorithms for converting bytes to decimal and
hexadecimal strings used by the fill() methods are essentially the same as used by the
dumpDecimal() and dumpHex() methods back in Chapter 4's FileDumper program.
Example 6.10. DecimalFilter
package com.macfaq.io;
import java.io.*;
91