InputStream's in
* order to form a single logical stream that can be read by applications
* that expect only one stream.
* * The streams passed to the constructor method are read in order until * they return -1 to indicate they are at end of stream. When a stream * reports end of stream, it is closed, then the next stream is read. * When the last stream is closed, the next attempt to read from this * stream will return a -1 to indicate it is at end of stream. *
* If this stream is closed prior to all subordinate streams being read
* to completion, all subordinate streams are closed.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy (warrenl@cygnus.com)
*/
public class SequenceInputStream extends InputStream
{
/** The handle for the current input stream. */
private InputStream in;
/** Secondary input stream; not used if constructed w/ enumeration. */
private InputStream in2;
/**
* The enumeration handle; not used if constructed w/ 2 explicit
* input streams.
*/
private Enumeration e;
/**
* This method creates a new SequenceInputStream that obtains
* its list of subordinate InputStreams from the specified
* Enumeration
*
* @param e An Enumeration that will return a list of
* InputStreams to read in sequence
*/
public SequenceInputStream(Enumeration e)
{
this.e = e;
in = e.nextElement();
in2 = null;
}
/**
* This method creates a new SequenceInputStream that will read
* the two specified subordinate InputStreams in sequence.
*
* @param s1 The first InputStream to read
* @param s2 The second InputStream to read
*/
public SequenceInputStream(InputStream s1, InputStream s2)
{
in = s1;
in2 = s2;
}
/**
* This method returns the number of bytes than can be read from the
* currently being read subordinate stream before that stream could
* block. Note that it is possible more bytes than this can actually
* be read without the stream blocking. If a 0 is returned, then the
* stream could block on the very next read.
*
* @return The number of bytes that can be read before blocking could occur
*
* @exception IOException If an error occurs
*/
public int available() throws IOException
{
if (in == null)
return 0;
return in.available();
}
/**
* Closes this stream. This will cause any remaining unclosed subordinate
* InputStream's to be closed as well. Subsequent attempts to
* read from this stream may cause an exception.
*
* @exception IOException If an error occurs
*/
public void close() throws IOException
{
while (in != null)
{
in.close();
in = getNextStream ();
}
}
/**
* This method reads an unsigned byte from the input stream and returns it
* as an int in the range of 0-255. This method also will return -1 if
* the end of the stream has been reached. This will only happen when
* all of the subordinate streams have been read.
*
* This method will block until the byte can be read.
*
* @return The byte read, or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public int read() throws IOException
{
int ch = -1;
while (in != null && (ch = in.read()) < 0)
{
in.close();
in = getNextStream();
}
return ch;
}
/**
* This method reads bytes from a stream and stores them into a caller
* supplied buffer. It starts storing the data at index offset
* into the buffer and attempts to read len bytes. This method
* can return before reading the number of bytes requested. The actual number
* of bytes read is returned as an int. A -1 is returend to indicate the
* end of the stream. This will only happen when all of the subordinate
* streams have been read.
*
* This method will block until at least one byte can be read.
*
* @param b The array into which bytes read should be stored
* @param off The offset into the array to start storing bytes
* @param len The requested number of bytes to read
*
* @return The actual number of bytes read, or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public int read(byte[] b, int off, int len) throws IOException
{
int ch = -1;
// The validity of the parameters will be checked by in.read so
// don't bother doing it here.
while (in != null && (ch = in.read(b, off, len)) < 0)
{
in.close();
in = getNextStream();
}
return ch;
}
/**
* This private method is used to get the next InputStream to
* read from. Returns null when no more streams are available.
*/
private InputStream getNextStream()
{
InputStream nextIn = null;
if (e != null)
{
if (e.hasMoreElements())
nextIn = e.nextElement();
}
else if (in2 != null)
{
nextIn = in2;
in2 = null;
}
return nextIn;
}
}