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

equal deleted inserted replaced

-:33de7752835c
+:94bb65cb37d3
 * <code>in</code>, for later use. Initially,
 * the pushback buffer is empty.
 *
 * @param  in    the input stream from which bytes will be read.
 * @param  size  the size of the pushback buffer.
-* @exception IllegalArgumentException if {@code size <= 0}
+* @throws IllegalArgumentException if {@code size <= 0}
 * @since  1.1
 */
 public PushbackInputStream(InputStream in, int size) {
 super(in);
 if (size <= 0) {
 * one, and otherwise calls the <code>read</code> method of its underlying
 * input stream and returns whatever value that method returns.
 *
 * @return     the next byte of data, or <code>-1</code> if the end of the
 *             stream has been reached.
-* @exception  IOException  if this input stream has been closed by
+* @throws     IOException  if this input stream has been closed by
 *             invoking its {@link #close()} method,
 *             or an I/O error occurs.
 * @see        java.io.InputStream#read()
 */
 public int read() throws IOException {
 * @param      off   the start offset in the destination array <code>b</code>
 * @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
 *             the stream has been reached.
-* @exception  NullPointerException If <code>b</code> is <code>null</code>.
+* @throws     NullPointerException If <code>b</code> is <code>null</code>.
-* @exception  IndexOutOfBoundsException If <code>off</code> is negative,
+* @throws     IndexOutOfBoundsException If <code>off</code> is negative,
-* <code>len</code> is negative, or <code>len</code> is greater than
+*             <code>len</code> is negative, or <code>len</code> is greater than
-* <code>b.length - off</code>
+*             <code>b.length - off</code>
-* @exception  IOException  if this input stream has been closed by
+* @throws     IOException  if this input stream has been closed by
 *             invoking its {@link #close()} method,
 *             or an I/O error occurs.
 * @see        java.io.InputStream#read(byte[], int, int)
 */
 public int read(byte[] b, int off, int len) throws IOException {
 * After this method returns, the next byte to be read will have the value
 * <code>(byte)b</code>.
 *
 * @param      b   the <code>int</code> value whose low-order
 *                  byte is to be pushed back.
-* @exception IOException If there is not enough room in the pushback
+* @throws    IOException If there is not enough room in the pushback
 *            buffer for the byte, or this input stream has been closed by
 *            invoking its {@link #close()} method.
 */
 public void unread(int b) throws IOException {
 ensureOpen();
 * Pushes back a portion of an array of bytes by copying it to the front
 * of the pushback buffer.  After this method returns, the next byte to be
 * read will have the value <code>b[off]</code>, the byte after that will
 * have the value <code>b[off+1]</code>, and so forth.
 *
-* @param b the byte array to push back.
+* @param     b the byte array to push back.
-* @param off the start offset of the data.
+* @param     off the start offset of the data.
-* @param len the number of bytes to push back.
+* @param     len the number of bytes to push back.
-* @exception NullPointerException If <code>b</code> is <code>null</code>.
+* @throws    NullPointerException If <code>b</code> is <code>null</code>.
-* @exception IOException If there is not enough room in the pushback
+* @throws    IOException If there is not enough room in the pushback
 *            buffer for the specified number of bytes,
 *            or this input stream has been closed by
 *            invoking its {@link #close()} method.
 * @since     1.1
 */
 * Pushes back an array of bytes by copying it to the front of the
 * pushback buffer.  After this method returns, the next byte to be read
 * will have the value <code>b[0]</code>, the byte after that will have the
 * value <code>b[1]</code>, and so forth.
 *
-* @param b the byte array to push back
+* @param     b the byte array to push back
-* @exception NullPointerException If <code>b</code> is <code>null</code>.
+* @throws    NullPointerException If <code>b</code> is <code>null</code>.
-* @exception IOException If there is not enough room in the pushback
+* @throws    IOException If there is not enough room in the pushback
 *            buffer for the specified number of bytes,
 *            or this input stream has been closed by
 *            invoking its {@link #close()} method.
 * @since     1.1
 */
 * pushed back and the value returned by {@link
 * java.io.FilterInputStream#available available}.
 *
 * @return     the number of bytes that can be read (or skipped over) from
 *             the input stream without blocking.
-* @exception  IOException  if this input stream has been closed by
+* @throws     IOException  if this input stream has been closed by
 *             invoking its {@link #close()} method,
 *             or an I/O error occurs.
 * @see        java.io.FilterInputStream#in
 * @see        java.io.InputStream#available()
 */
 * Tests if this input stream supports the <code>mark</code> and
 * <code>reset</code> methods, which it does not.
 *
 * @return   <code>false</code>, since this class does not support the
 *           <code>mark</code> and <code>reset</code> methods.
-* @see     java.io.InputStream#mark(int)
+* @see      java.io.InputStream#mark(int)
-* @see     java.io.InputStream#reset()
+* @see      java.io.InputStream#reset()
 */
 public boolean markSupported() {
 return false;
 }
 *
 * <p> The method <code>reset</code> for class
 * <code>PushbackInputStream</code> does nothing except throw an
 * <code>IOException</code>.
 *
-* @exception  IOException  if this method is invoked.
+* @throws  IOException  if this method is invoked.
 * @see     java.io.InputStream#mark(int)
 * @see     java.io.IOException
 */
 public synchronized void reset() throws IOException {
 throw new IOException("mark/reset not supported");
 * associated with the stream.
 * Once the stream has been closed, further read(), unread(),
 * available(), reset(), or skip() invocations will throw an IOException.
 * Closing a previously closed stream has no effect.
 *
-* @exception  IOException  if an I/O error occurs.
+* @throws     IOException  if an I/O error occurs.
 */
 public synchronized void close() throws IOException {
 if (in == null)
 return;
 in.close();

changeset 58242	94bb65cb37d3
parent 55730	94f8a0b34117
child 58288	48e480e56aad