/*
* Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.io;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Vector;
A 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: 1.0
/**
* A <code>SequenceInputStream</code> 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 1.0
*/
public
class SequenceInputStream extends InputStream {
Enumeration<? extends InputStream> e;
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.
Params: - e – an enumeration of input streams.
See Also:
/**
* Initializes a newly created <code>SequenceInputStream</code>
* by remembering the argument, which must
* be an <code>Enumeration</code> that produces
* objects whose run-time type is <code>InputStream</code>.
* The input streams that are produced by
* the enumeration will be read, in order,
* to provide the bytes to be read from this
* <code>SequenceInputStream</code>. After
* each input stream from the enumeration
* is exhausted, it is closed by calling its
* <code>close</code> method.
*
* @param e an enumeration of input streams.
* @see java.util.Enumeration
*/
public SequenceInputStream(Enumeration<? extends InputStream> e) {
this.e = e;
peekNextStream();
}
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
.
Params: - s1 – the first input stream to read.
- s2 – the second input stream to read.
/**
* Initializes a newly
* created <code>SequenceInputStream</code>
* by remembering the two arguments, which
* will be read in order, first <code>s1</code>
* and then <code>s2</code>, to provide the
* bytes to be read from this <code>SequenceInputStream</code>.
*
* @param s1 the first input stream to read.
* @param s2 the second input stream to read.
*/
public SequenceInputStream(InputStream s1, InputStream s2) {
Vector<InputStream> v = new Vector<>(2);
v.addElement(s1);
v.addElement(s2);
e = v.elements();
peekNextStream();
}
Continues reading in the next stream if an EOF is reached.
/**
* Continues reading in the next stream if an EOF is reached.
*/
final void nextStream() throws IOException {
if (in != null) {
in.close();
}
peekNextStream();
}
private void peekNextStream() {
if (e.hasMoreElements()) {
in = (InputStream) e.nextElement();
if (in == null)
throw new NullPointerException();
} else {
in = null;
}
}
Returns an estimate of the number of bytes that can be read (or
skipped over) from the current underlying input stream without
blocking by the next invocation of a method for the current
underlying input stream. The next invocation might be
the same thread or another thread. A single read or skip of this
many bytes will not block, but may read or skip fewer bytes.
This method simply calls available
of the current underlying input stream and returns the result.
Throws: - IOException – if an I/O error occurs.
Returns: an estimate of the number of bytes that can be read (or skipped over) from the current underlying input stream without blocking or 0
if this input stream has been closed by invoking its close()
method Since: 1.1
/**
* Returns an estimate of the number of bytes that can be read (or
* skipped over) from the current underlying input stream without
* blocking by the next invocation of a method for the current
* underlying input stream. The next invocation might be
* the same thread or another thread. A single read or skip of this
* many bytes will not block, but may read or skip fewer bytes.
* <p>
* 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 1.1
*/
public int available() throws IOException {
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.
Throws: - IOException – if an I/O error occurs.
Returns: the next byte of data, or -1
if the end of the
stream is reached.
/**
* Reads the next byte of data from this input stream. The byte is
* returned as an <code>int</code> in the range <code>0</code> to
* <code>255</code>. If no byte is available because the end of the
* stream has been reached, the value <code>-1</code> is returned.
* This method blocks until input data is available, the end of the
* stream is detected, or an exception is thrown.
* <p>
* This method
* tries to read one character from the current substream. If it
* reaches the end of the stream, it calls the <code>close</code>
* method of the current substream and begins reading from the next
* substream.
*
* @return the next byte of data, or <code>-1</code> if the end of the
* stream is reached.
* @exception IOException if an I/O error occurs.
*/
public int read() throws IOException {
while (in != null) {
int c = in.read();
if (c != -1) {
return c;
}
nextStream();
}
return -1;
}
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.
Params: - b – the buffer into which the data is read.
- off – the start offset in array
b
at which the data is written. - len – the maximum number of bytes read.
Throws: - NullPointerException – If
b
is null
. - IndexOutOfBoundsException – If
off
is negative,
len
is negative, or len
is greater than
b.length - off
- IOException – if an I/O error occurs.
Returns: int the number of bytes read.
/**
* Reads up to <code>len</code> bytes of data from this input stream
* into an array of bytes. If <code>len</code> is not zero, the method
* blocks until at least 1 byte of input is available; otherwise, no
* bytes are read and <code>0</code> is returned.
* <p>
* The <code>read</code> method of <code>SequenceInputStream</code>
* 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 <code>close</code> 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 <code>b</code>
* at which the data is written.
* @param len the maximum number of bytes read.
* @return int the number of bytes read.
* @exception NullPointerException If <code>b</code> is <code>null</code>.
* @exception IndexOutOfBoundsException If <code>off</code> is negative,
* <code>len</code> is negative, or <code>len</code> is greater than
* <code>b.length - off</code>
* @exception IOException if an I/O error occurs.
*/
public int read(byte b[], int off, int len) throws IOException {
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;
}
do {
int n = in.read(b, off, len);
if (n > 0) {
return n;
}
nextStream();
} while (in != null);
return -1;
}
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.
Throws: - IOException – if an I/O error occurs.
/**
* Closes this input stream and releases any system resources
* associated with the stream.
* A closed <code>SequenceInputStream</code>
* cannot perform input operations and cannot
* be reopened.
* <p>
* If this stream was created
* from an enumeration, all remaining elements
* are requested from the enumeration and closed
* before the <code>close</code> method returns.
*
* @exception IOException if an I/O error occurs.
*/
public void close() throws IOException {
do {
nextStream();
} while (in != null);
}
}