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

equal deleted inserted replaced

-:a7f16447085e
+:48e480e56aad
 /**
 * A piped input stream should be connected
 * to a piped output stream; the piped  input
 * stream then provides whatever data bytes
 * are written to the piped output  stream.
-* Typically, data is read from a <code>PipedInputStream</code>
+* Typically, data is read from a {@code PipedInputStream}
 * object by one thread  and data is written
-* to the corresponding <code>PipedOutputStream</code>
+* to the corresponding {@code PipedOutputStream}
 * by some  other thread. Attempting to use
 * both objects from a single thread is not
 * recommended, as it may deadlock the thread.
 * The piped input stream contains a buffer,
 * decoupling read operations from write operations,
 /**
 * The index of the position in the circular buffer at which the
 * next byte of data will be stored when received from the connected
 * piped output stream. <code>in&lt;0</code> implies the buffer is empty,
-* <code>in==out</code> implies the buffer is full
+* {@code in==out} implies the buffer is full
 * @since   1.1
 */
 protected int in = -1;
 /**
 * @since   1.1
 */
 protected int out = 0;
 /**
-* Creates a <code>PipedInputStream</code> so
+* Creates a {@code PipedInputStream} so
 * that it is connected to the piped output
-* stream <code>src</code>. Data bytes written
+* stream {@code src}. Data bytes written
-* to <code>src</code> will then be  available
+* to {@code src} will then be  available
 * as input from this stream.
 *
 * @param      src   the stream to connect to.
 * @throws     IOException  if an I/O error occurs.
 */
 public PipedInputStream(PipedOutputStream src) throws IOException {
 this(src, DEFAULT_PIPE_SIZE);
 }
 /**
-* Creates a <code>PipedInputStream</code> so that it is
+* Creates a {@code PipedInputStream} so that it is
 * connected to the piped output stream
-* <code>src</code> and uses the specified pipe size for
+* {@code src} and uses the specified pipe size for
 * the pipe's buffer.
-* Data bytes written to <code>src</code> will then
+* Data bytes written to {@code src} will then
 * be available as input from this stream.
 *
 * @param      src   the stream to connect to.
 * @param      pipeSize the size of the pipe's buffer.
 * @throws     IOException  if an I/O error occurs.
 initPipe(pipeSize);
 connect(src);
 }
 /**
-* Creates a <code>PipedInputStream</code> so
+* Creates a {@code PipedInputStream} so
 * that it is not yet {@linkplain #connect(java.io.PipedOutputStream)
 * connected}.
 * It must be {@linkplain java.io.PipedOutputStream#connect(
 * java.io.PipedInputStream) connected} to a
-* <code>PipedOutputStream</code> before being used.
+* {@code PipedOutputStream} before being used.
 */
 public PipedInputStream() {
 initPipe(DEFAULT_PIPE_SIZE);
 }
 /**
-* Creates a <code>PipedInputStream</code> so that it is not yet
+* Creates a {@code PipedInputStream} so that it is not yet
 * {@linkplain #connect(java.io.PipedOutputStream) connected} and
 * uses the specified pipe size for the pipe's buffer.
 * It must be {@linkplain java.io.PipedOutputStream#connect(
 * java.io.PipedInputStream)
-* connected} to a <code>PipedOutputStream</code> before being used.
+* connected} to a {@code PipedOutputStream} before being used.
 *
 * @param      pipeSize the size of the pipe's buffer.
 * @throws     IllegalArgumentException if {@code pipeSize <= 0}.
 * @since      1.6
 */
 buffer = new byte[pipeSize];
 }
 /**
 * Causes this piped input stream to be connected
-* to the piped  output stream <code>src</code>.
+* to the piped  output stream {@code src}.
 * If this object is already connected to some
-* other piped output  stream, an <code>IOException</code>
+* other piped output  stream, an {@code IOException}
 * is thrown.
 * <p>
-* If <code>src</code> is an
+* If {@code src} is an
-* unconnected piped output stream and <code>snk</code>
+* unconnected piped output stream and {@code snk}
 * is an unconnected piped input stream, they
 * may be connected by either the call:
 *
-* <pre><code>snk.connect(src)</code> </pre>
+* <pre>{@code snk.connect(src)} </pre>
 * <p>
 * or the call:
 *
-* <pre><code>src.connect(snk)</code> </pre>
+* <pre>{@code src.connect(snk)} </pre>
 * <p>
 * The two calls have the same effect.
 *
 * @param      src   The piped output stream to connect to.
 * @throws     IOException  if an I/O error occurs.
 /**
 * Receives a byte of data.  This method will block if no input is
 * available.
 * @param   b the byte being received
-* @throws  IOException If the pipe is <a href="#BROKEN"> <code>broken</code></a>,
+* @throws  IOException If the pipe is <a href="#BROKEN"> {@code broken}</a>,
 *          {@link #connect(java.io.PipedOutputStream) unconnected},
 *          closed, or if an I/O error occurs.
 * @since   1.1
 */
 protected synchronized void receive(int b) throws IOException {
 notifyAll();
 }
 /**
 * Reads the next byte of data from this piped input stream. The
-* value byte is returned as an <code>int</code> in the range
+* value byte is returned as an {@code int} in the range
-* <code>0</code> to <code>255</code>.
+* {@code 0} to {@code 255}.
 * This method blocks until input data is available, the end of the
 * stream is detected, or an exception is thrown.
 *
-* @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 the pipe is
 *           {@link #connect(java.io.PipedOutputStream) unconnected},
-*           <a href="#BROKEN"> <code>broken</code></a>, closed,
+*           <a href="#BROKEN"> {@code broken}</a>, closed,
 *           or if an I/O error occurs.
 */
 public synchronized int read()  throws IOException {
 if (!connected) {
 throw new IOException("Pipe not connected");
 return ret;
 }
 /**
-* Reads up to <code>len</code> bytes of data from this piped input
+* Reads up to {@code len} bytes of data from this piped input
-* stream into an array of bytes. Less than <code>len</code> bytes
+* stream into an array of bytes. Less than {@code len} bytes
 * will be read if the end of the data stream is reached or if
-* <code>len</code> exceeds the pipe's buffer size.
+* {@code len} exceeds the pipe's buffer size.
-* If <code>len </code> is zero, then no bytes are read and 0 is returned;
+* If {@code len } is zero, then no bytes are read and 0 is returned;
 * otherwise, the method blocks until at least 1 byte of input is
 * available, end of the stream has been detected, or an exception is
 * thrown.
 *
 * @param      b     the buffer into which the data is read.
-* @param      off   the start offset in the destination array <code>b</code>
+* @param      off   the start offset in the destination array {@code b}
 * @param      len   the maximum number of bytes read.
 * @return     the total number of bytes read into the buffer, or
-*             <code>-1</code> if there is no more data because the end of
+*             {@code -1} if there is no more data because the end of
 *             the stream has been reached.
-* @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 greater than
+*             {@code len} is negative, or {@code len} is greater than
-*             <code>b.length - off</code>
+*             {@code b.length - off}
-* @throws     IOException if the pipe is <a href="#BROKEN"> <code>broken</code></a>,
+* @throws     IOException if the pipe is <a href="#BROKEN"> {@code broken}</a>,
 *           {@link #connect(java.io.PipedOutputStream) unconnected},
 *           closed, or if an I/O error occurs.
 */
 public synchronized int read(byte b[], int off, int len)  throws IOException {
 if (b == null) {
 *
 * @return the number of bytes that can be read from this input stream
 *         without blocking, or {@code 0} if this input stream has been
 *         closed by invoking its {@link #close()} method, or if the pipe
 *         is {@link #connect(java.io.PipedOutputStream) unconnected}, or
-*         <a href="#BROKEN"> <code>broken</code></a>.
+*         <a href="#BROKEN"> {@code broken}</a>.
 *
 * @throws IOException  if an I/O error occurs.
 * @since  1.0.2
 */
 public synchronized int available() throws IOException {

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