jdk-sandbox: comparison src/java.base/share/classes/java/io/SequenceInputStream.java

equal deleted inserted replaced

-:a7f16447085e
+:48e480e56aad
 import java.io.InputStream;
 import java.util.Enumeration;
 import java.util.Vector;
 /**
-* A <code>SequenceInputStream</code> represents
+* A {@code 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,
 class SequenceInputStream extends InputStream {
 Enumeration<? extends InputStream> e;
 InputStream in;
 /**
-* Initializes a newly created <code>SequenceInputStream</code>
+* Initializes a newly created {@code SequenceInputStream}
 * by remembering the argument, which must
-* be an <code>Enumeration</code>  that produces
+* be an {@code Enumeration}  that produces
-* objects whose run-time type is <code>InputStream</code>.
+* objects whose run-time type is {@code InputStream}.
 * 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
+* {@code SequenceInputStream}. After
 * each input stream from the enumeration
 * is exhausted, it is closed by calling its
-* <code>close</code> method.
+* {@code close} method.
 *
 * @param   e   an enumeration of input streams.
 * @see     java.util.Enumeration
 */
 public SequenceInputStream(Enumeration<? extends InputStream> e) {
 peekNextStream();
 }
 /**
 * Initializes a newly
-* created <code>SequenceInputStream</code>
+* created {@code SequenceInputStream}
 * by remembering the two arguments, which
-* will be read in order, first <code>s1</code>
+* will be read in order, first {@code s1}
-* and then <code>s2</code>, to provide the
+* and then {@code s2}, to provide the
-* bytes to be read from this <code>SequenceInputStream</code>.
+* bytes to be read from this {@code SequenceInputStream}.
 *
 * @param   s1   the first input stream to read.
 * @param   s2   the second input stream to read.
 */
 public SequenceInputStream(InputStream s1, InputStream s2) {
 return in.available();
 }
 /**
 * 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
+* returned as an {@code int} in the range {@code 0} to
-* <code>255</code>. If no byte is available because the end of the
+* {@code 255}. If no byte is available because the end of the
-* stream has been reached, the value <code>-1</code> is returned.
+* stream has been reached, the value {@code -1} 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>
+* reaches the end of the stream, it calls the {@code close}
 * 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
+* @return     the next byte of data, or {@code -1} if the end of the
 *             stream is reached.
 * @throws     IOException  if an I/O error occurs.
 */
 public int read() throws IOException {
 while (in != null) {
 }
 return -1;
 }
 /**
-* Reads up to <code>len</code> bytes of data from this input stream
+* Reads up to {@code len} bytes of data from this input stream
-* into an array of bytes.  If <code>len</code> is not zero, the method
+* into an array of bytes.  If {@code len} 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.
+* bytes are read and {@code 0} is returned.
 * <p>
-* The <code>read</code> method of <code>SequenceInputStream</code>
+* The {@code read} method of {@code 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 <code>close</code> method of the current
+* the stream, it calls the {@code 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 <code>b</code>
+* @param      off   the start offset in array {@code b}
 *                   at which the data is written.
 * @param      len   the maximum number of bytes read.
 * @return     int   the number of bytes read.
-* @throws     NullPointerException If <code>b</code> is <code>null</code>.
+* @throws     NullPointerException If {@code b} is {@code null}.
-* @throws     IndexOutOfBoundsException If <code>off</code> is negative,
+* @throws     IndexOutOfBoundsException If {@code off} is negative,
-*             <code>len</code> is negative, or <code>len</code> is
+*             {@code len} is negative, or {@code len} is
-*             greater than <code>b.length - off</code>
+*             greater than {@code b.length - off}
 * @throws     IOException  if an I/O error occurs.
 */
 public int read(byte b[], int off, int len) throws IOException {
 if (in == null) {
 return -1;
 }
 /**
 * Closes this input stream and releases any system resources
 * associated with the stream.
-* A closed <code>SequenceInputStream</code>
+* A closed {@code SequenceInputStream}
 * 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.
+* before the {@code close} method returns.
 *
 * @throws     IOException  if an I/O error occurs.
 */
 public void close() throws IOException {
 IOException ioe = null;

changeset 58288	48e480e56aad
parent 58242	94bb65cb37d3
child 58679	9c3209ff7550
child 59201	b24f4caa1411