SequenceInputStream represents the logical concatenation of other input streams. It starts out with an
* ordered collection of input streams and reads from the first one until end of file is reached, whereupon it reads
* from the second one, and so on, until end of file is reached on the last of the contained input streams.
*
* @author Author van Hoff
* @since JDK1.0
*/
public class SequenceInputStream extends InputStream {
Enumeration e;
@Nullable
InputStream in;
/**
* Initializes a newly created SequenceInputStream by remembering the argument, which must be an
* Enumeration that produces objects whose run-time type is InputStream. The input streams
* that are produced by the enumeration will be read, in order, to provide the bytes to be read from this
* SequenceInputStream. After each input stream from the enumeration is exhausted, it is closed by
* calling its close method.
*
* @param e
* an enumeration of input streams.
* @see java.util.Enumeration
*/
public SequenceInputStream(Enumeration e) {
this.e = e;
try {
nextStream();
} catch (IOException ex) {
// This should never happen
throw new Error("panic");
}
}
/**
* Initializes a newly created SequenceInputStream by remembering the two arguments, which will be read
* in order, first s1 and then s2, to provide the bytes to be read from this
* SequenceInputStream.
*
* @param s1
* the first input stream to read.
* @param s2
* the second input stream to read.
*/
public SequenceInputStream(InputStream s1, InputStream s2) {
Vector
* This method simply calls {@code available} of the current underlying input stream and returns the result.
*
* @return an estimate of the number of bytes that can be read (or skipped over) from the current underlying input
* stream without blocking or {@code 0} if this input stream has been closed by invoking its
* {@link #close()} method
* @exception IOException
* if an I/O error occurs.
*
* @since JDK1.1
*/
@Override
public int available() throws IOException {
InputStream in = this.in;
if (in == null) {
return 0; // no way to signal EOF from available()
}
return in.available();
}
/**
* Reads the next byte of data from this input stream. The byte is returned as an int in the range
* 0 to 255. If no byte is available because the end of the stream has been reached, the
* value -1 is returned. This method blocks until input data is available, the end of the stream is
* detected, or an exception is thrown.
*
* This method tries to read one character from the current substream. If it reaches the end of the stream, it calls
* the close method of the current substream and begins reading from the next substream.
*
* @return the next byte of data, or -1 if the end of the stream is reached.
* @exception IOException
* if an I/O error occurs.
*/
@Override
public int read() throws IOException {
InputStream in = this.in;
if (in == null) {
return -1;
}
int c = in.read();
if (c == -1) {
nextStream();
return read();
}
return c;
}
/**
* Reads up to len bytes of data from this input stream into an array of bytes. If len is
* not zero, the method blocks until at least 1 byte of input is available; otherwise, no bytes are read and
* 0 is returned.
*
* The read method of SequenceInputStream tries to read the data from the current
* substream. If it fails to read any characters because the substream has reached the end of the stream, it calls
* the close method of the current substream and begins reading from the next substream.
*
* @param b
* the buffer into which the data is read.
* @param off
* the start offset in array b at which the data is written.
* @param len
* the maximum number of bytes read.
* @return int the number of bytes read.
* @exception NullPointerException
* If b is null.
* @exception IndexOutOfBoundsException
* If off is negative, len is negative, or len is greater than
* b.length - off
* @exception IOException
* if an I/O error occurs.
*/
@Override
public int read(@Nullable byte b[], int off, int len) throws IOException {
InputStream in = this.in;
if (in == null) {
return -1;
} else if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int n = in.read(b, off, len);
if (n <= 0) {
nextStream();
return read(b, off, len);
}
return n;
}
/**
* Closes this input stream and releases any system resources associated with the stream. A closed
* SequenceInputStream cannot perform input operations and cannot be reopened.
*
* If this stream was created from an enumeration, all remaining elements are requested from the enumeration and
* closed before the close method returns.
*
* @exception IOException
* if an I/O error occurs.
*/
@Override
public void close() throws IOException {
do {
nextStream();
} while (this.in != null);
}
}