< prev index next >

src/java.desktop/share/classes/javax/imageio/stream/ImageOutputStream.java

Print this page

        

@@ -28,17 +28,17 @@
 import java.io.DataOutput;
 import java.io.IOException;
 
 /**
  * A seekable output stream interface for use by
- * <code>ImageWriter</code>s.  Various output destinations, such as
- * <code>OutputStream</code>s and <code>File</code>s, as well as
+ * {@code ImageWriter}s.  Various output destinations, such as
+ * {@code OutputStream}s and {@code File}s, as well as
  * future fast I/O destinations may be "wrapped" by a suitable
  * implementation of this interface for use by the Image I/O API.
  *
- * <p> Unlike a standard <code>OutputStream</code>, ImageOutputStream
- * extends its counterpart, <code>ImageInputStream</code>.  Thus it is
+ * <p> Unlike a standard {@code OutputStream}, ImageOutputStream
+ * extends its counterpart, {@code ImageInputStream}.  Thus it is
  * possible to read from the stream as it is being written.  The same
  * seek and flush positions apply to both reading and writing, although
  * the semantics for dealing with a non-zero bit offset before a byte-aligned
  * write are necessarily different from the semantics for dealing with
  * a non-zero bit offset before a byte-aligned read.  When reading bytes,

@@ -51,111 +51,111 @@
  */
 public interface ImageOutputStream extends ImageInputStream, DataOutput {
 
     /**
      * Writes a single byte to the stream at the current position.
-     * The 24 high-order bits of <code>b</code> are ignored.
+     * The 24 high-order bits of {@code b} are ignored.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.  Implementers can use the
      * {@link ImageOutputStreamImpl#flushBits flushBits}
      * method of {@link ImageOutputStreamImpl ImageOutputStreamImpl}
      * to guarantee this.
      *
-     * @param b an <code>int</code> whose lower 8 bits are to be
+     * @param b an {@code int} whose lower 8 bits are to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void write(int b) throws IOException;
 
     /**
      * Writes a sequence of bytes to the stream at the current
-     * position.  If <code>b.length</code> is 0, nothing is written.
-     * The byte <code>b[0]</code> is written first, then the byte
-     * <code>b[1]</code>, and so on.
+     * position.  If {@code b.length} is 0, nothing is written.
+     * The byte {@code b[0]} is written first, then the byte
+     * {@code b[1]}, and so on.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param b an array of <code>byte</code>s to be written.
+     * @param b an array of {@code byte}s to be written.
      *
-     * @exception NullPointerException if <code>b</code> is
-     * <code>null</code>.
+     * @exception NullPointerException if {@code b} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void write(byte b[]) throws IOException;
 
     /**
      * Writes a sequence of bytes to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The byte <code>b[off]</code> is written first, then the byte
-     * <code>b[off + 1]</code>, and so on.
+     * position.  If {@code len} is 0, nothing is written.
+     * The byte {@code b[off]} is written first, then the byte
+     * {@code b[off + 1]}, and so on.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.  Implementers can use the
      * {@link ImageOutputStreamImpl#flushBits flushBits}
      * method of {@link ImageOutputStreamImpl ImageOutputStreamImpl}
      * to guarantee this.
      *
-     * @param b an array of <code>byte</code>s to be written.
+     * @param b an array of {@code byte}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>byte</code>s to write.
+     * @param len the number of {@code byte}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>b.length</code>.
-     * @exception NullPointerException if <code>b</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code b.length}.
+     * @exception NullPointerException if {@code b} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void write(byte b[], int off, int len) throws IOException;
 
     /**
-     * Writes a <code>boolean</code> value to the stream.  If
-     * <code>v</code> is true, the value <code>(byte)1</code> is
-     * written; if <code>v</code> is false, the value
-     * <code>(byte)0</code> is written.
+     * Writes a {@code boolean} value to the stream.  If
+     * {@code v} is true, the value {@code (byte)1} is
+     * written; if {@code v} is false, the value
+     * {@code (byte)0} is written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v the <code>boolean</code> to be written.
+     * @param v the {@code boolean} to be written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeBoolean(boolean v) throws IOException;
 
     /**
-     * Writes the 8 low-order bits of <code>v</code> to the
-     * stream. The 24 high-order bits of <code>v</code> are ignored.
-     * (This means that <code>writeByte</code> does exactly the same
-     * thing as <code>write</code> for an integer argument.)
+     * Writes the 8 low-order bits of {@code v} to the
+     * stream. The 24 high-order bits of {@code v} are ignored.
+     * (This means that {@code writeByte} does exactly the same
+     * thing as {@code write} for an integer argument.)
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v an <code>int</code> containing the byte value to be
+     * @param v an {@code int} containing the byte value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeByte(int v) throws IOException;
 
     /**
-     * Writes the 16 low-order bits of <code>v</code> to the
-     * stream. The 16 high-order bits of <code>v</code> are ignored.
+     * Writes the 16 low-order bits of {@code v} to the
+     * stream. The 16 high-order bits of {@code v} are ignored.
      * If the stream uses network byte order, the bytes written, in
      * order, will be:
      *
      * <pre>
      * (byte)((v &gt;&gt; 8) &amp; 0xff)

@@ -172,31 +172,31 @@
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v an <code>int</code> containing the short value to be
+     * @param v an {@code int} containing the short value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeShort(int v) throws IOException;
 
     /**
      * This method is a synonym for {@link #writeShort writeShort}.
      *
-     * @param v an <code>int</code> containing the char (unsigned
+     * @param v an {@code int} containing the char (unsigned
      * short) value to be written.
      *
      * @exception IOException if an I/O error occurs.
      *
      * @see #writeShort(int)
      */
     void writeChar(int v) throws IOException;
 
     /**
-     * Writes the 32 bits of <code>v</code> to the stream.  If the
+     * Writes the 32 bits of {@code v} to the stream.  If the
      * stream uses network byte order, the bytes written, in order,
      * will be:
      *
      * <pre>
      * (byte)((v &gt;&gt; 24) &amp; 0xff)

@@ -217,19 +217,19 @@
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v an <code>int</code> containing the value to be
+     * @param v an {@code int} containing the value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeInt(int v) throws IOException;
 
     /**
-     * Writes the 64 bits of <code>v</code> to the stream.  If the
+     * Writes the 64 bits of {@code v} to the stream.  If the
      * stream uses network byte order, the bytes written, in order,
      * will be:
      *
      * <pre>
      * (byte)((v &gt;&gt; 56) &amp; 0xff)

@@ -258,161 +258,161 @@
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v a <code>long</code> containing the value to be
+     * @param v a {@code long} containing the value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeLong(long v) throws IOException;
 
     /**
-     * Writes a <code>float</code> value, which is comprised of four
+     * Writes a {@code float} value, which is comprised of four
      * bytes, to the output stream. It does this as if it first
-     * converts this <code>float</code> value to an <code>int</code>
-     * in exactly the manner of the <code>Float.floatToIntBits</code>
+     * converts this {@code float} value to an {@code int}
+     * in exactly the manner of the {@code Float.floatToIntBits}
      * method and then writes the int value in exactly the manner of
-     * the <code>writeInt</code> method.
+     * the {@code writeInt} method.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v a <code>float</code> containing the value to be
+     * @param v a {@code float} containing the value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeFloat(float v) throws IOException;
 
     /**
-     * Writes a <code>double</code> value, which is comprised of four
+     * Writes a {@code double} value, which is comprised of four
      * bytes, to the output stream. It does this as if it first
-     * converts this <code>double</code> value to an <code>long</code>
+     * converts this {@code double} value to an {@code long}
      * in exactly the manner of the
-     * <code>Double.doubleToLongBits</code> method and then writes the
-     * long value in exactly the manner of the <code>writeLong</code>
+     * {@code Double.doubleToLongBits} method and then writes the
+     * long value in exactly the manner of the {@code writeLong}
      * method.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param v a <code>double</code> containing the value to be
+     * @param v a {@code double} containing the value to be
      * written.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeDouble(double v) throws IOException;
 
     /**
      * Writes a string to the output stream. For every character in
-     * the string <code>s</code>, taken in order, one byte is written
-     * to the output stream. If <code>s</code> is <code>null</code>, a
-     * <code>NullPointerException</code> is thrown.
-     *
-     * <p> If <code>s.length</code> is zero, then no bytes are
-     * written. Otherwise, the character <code>s[0]</code> is written
-     * first, then <code>s[1]</code>, and so on; the last character
-     * written is <code>s[s.length-1]</code>. For each character, one
+     * the string {@code s}, taken in order, one byte is written
+     * to the output stream. If {@code s} is {@code null}, a
+     * {@code NullPointerException} is thrown.
+     *
+     * <p> If {@code s.length} is zero, then no bytes are
+     * written. Otherwise, the character {@code s[0]} is written
+     * first, then {@code s[1]}, and so on; the last character
+     * written is {@code s[s.length-1]}. For each character, one
      * byte is written, the low-order byte, in exactly the manner of
-     * the <code>writeByte</code> method. The high-order eight bits of
+     * the {@code writeByte} method. The high-order eight bits of
      * each character in the string are ignored.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param s a <code>String</code> containing the value to be
+     * @param s a {@code String} containing the value to be
      * written.
      *
-     * @exception NullPointerException if <code>s</code> is
-     * <code>null</code>.
+     * @exception NullPointerException if {@code s} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeBytes(String s) throws IOException;
 
     /**
      * Writes a string to the output stream. For every character in
-     * the string <code>s</code>, taken in order, two bytes are
+     * the string {@code s}, taken in order, two bytes are
      * written to the output stream, ordered according to the current
      * byte order setting.  If network byte order is being used, the
      * high-order byte is written first; the order is reversed
-     * otherwise.  If <code>s</code> is <code>null</code>, a
-     * <code>NullPointerException</code> is thrown.
+     * otherwise.  If {@code s} is {@code null}, a
+     * {@code NullPointerException} is thrown.
      *
-     * <p> If <code>s.length</code> is zero, then no bytes are
-     * written. Otherwise, the character <code>s[0]</code> is written
-     * first, then <code>s[1]</code>, and so on; the last character
-     * written is <code>s[s.length-1]</code>.
+     * <p> If {@code s.length} is zero, then no bytes are
+     * written. Otherwise, the character {@code s[0]} is written
+     * first, then {@code s[1]}, and so on; the last character
+     * written is {@code s[s.length-1]}.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param s a <code>String</code> containing the value to be
+     * @param s a {@code String} containing the value to be
      * written.
      *
-     * @exception NullPointerException if <code>s</code> is
-     * <code>null</code>.
+     * @exception NullPointerException if {@code s} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeChars(String s) throws IOException;
 
     /**
      * Writes two bytes of length information to the output stream in
      * network byte order, followed by the
      * <a href="../../../java/io/DataInput.html#modified-utf-8">modified
      * UTF-8</a>
-     * representation of every character in the string <code>s</code>.
-     * If <code>s</code> is <code>null</code>, a
-     * <code>NullPointerException</code> is thrown.  Each character in
-     * the string <code>s</code> is converted to a group of one, two,
+     * representation of every character in the string {@code s}.
+     * If {@code s} is {@code null}, a
+     * {@code NullPointerException} is thrown.  Each character in
+     * the string {@code s} is converted to a group of one, two,
      * or three bytes, depending on the value of the character.
      *
-     * <p> If a character <code>c</code> is in the range
+     * <p> If a character {@code c} is in the range
      * <code>\u0001</code> through <code>\u007f</code>, it is
      * represented by one byte:
      *
      * <pre>
      * (byte)c
      * </pre>
      *
-     * <p> If a character <code>c</code> is <code>\u0000</code> or
+     * <p> If a character {@code c} is <code>\u0000</code> or
      * is in the range <code>\u0080</code> through
      * <code>\u07ff</code>, then it is represented by two bytes,
      * to be written in the order shown:
      *
      * <pre><code>
      * (byte)(0xc0 | (0x1f &amp; (c &gt;&gt; 6)))
      * (byte)(0x80 | (0x3f &amp; c))
      * </code></pre>
      *
-     * <p> If a character <code>c</code> is in the range
-     * <code>\u0800</code> through <code>uffff</code>, then it is
+     * <p> If a character {@code c} is in the range
+     * <code>\u0800</code> through {@code uffff}, then it is
      * represented by three bytes, to be written in the order shown:
      *
      * <pre><code>
      * (byte)(0xe0 | (0x0f &amp; (c &gt;&gt; 12)))
      * (byte)(0x80 | (0x3f &amp; (c &gt;&gt; 6)))
      * (byte)(0x80 | (0x3f &amp; c))
      * </code></pre>
      *
      * <p> First, the total number of bytes needed to represent all
-     * the characters of <code>s</code> is calculated. If this number
-     * is larger than <code>65535</code>, then a
-     * <code>UTFDataFormatException</code> is thrown. Otherwise, this
+     * the characters of {@code s} is calculated. If this number
+     * is larger than {@code 65535}, then a
+     * {@code UTFDataFormatException} is thrown. Otherwise, this
      * length is written to the output stream in exactly the manner of
-     * the <code>writeShort</code> method; after this, the one-, two-,
+     * the {@code writeShort} method; after this, the one-, two-,
      * or three-byte representation of each character in the string
-     * <code>s</code> is written.
+     * {@code s} is written.
      *
      * <p> The current byte order setting is ignored.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s

@@ -422,173 +422,173 @@
      * <p><strong>Note:</strong> This method should not be used in
      * the  implementation of image formats that use standard UTF-8,
      * because  the modified UTF-8 used here is incompatible with
      * standard UTF-8.
      *
-     * @param s a <code>String</code> containing the value to be
+     * @param s a {@code String} containing the value to be
      * written.
      *
-     * @exception NullPointerException if <code>s</code> is
-     * <code>null</code>.
+     * @exception NullPointerException if {@code s} is
+     * {@code null}.
      * @exception java.io.UTFDataFormatException if the modified UTF-8
-     * representation of <code>s</code> requires more than 65536 bytes.
+     * representation of {@code s} requires more than 65536 bytes.
      * @exception IOException if an I/O error occurs.
      */
     void writeUTF(String s) throws IOException;
 
     /**
      * Writes a sequence of shorts to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The short <code>s[off]</code> is written first, then the short
-     * <code>s[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The short {@code s[off]} is written first, then the short
+     * {@code s[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param s an array of <code>short</code>s to be written.
+     * @param s an array of {@code short}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>short</code>s to write.
+     * @param len the number of {@code short}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>s.length</code>.
-     * @exception NullPointerException if <code>s</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code s.length}.
+     * @exception NullPointerException if {@code s} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeShorts(short[] s, int off, int len) throws IOException;
 
     /**
      * Writes a sequence of chars to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The char <code>c[off]</code> is written first, then the char
-     * <code>c[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The char {@code c[off]} is written first, then the char
+     * {@code c[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param c an array of <code>char</code>s to be written.
+     * @param c an array of {@code char}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>char</code>s to write.
+     * @param len the number of {@code char}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>c.length</code>.
-     * @exception NullPointerException if <code>c</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code c.length}.
+     * @exception NullPointerException if {@code c} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeChars(char[] c, int off, int len) throws IOException;
 
     /**
      * Writes a sequence of ints to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The int <code>i[off]</code> is written first, then the int
-     * <code>i[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The int {@code i[off]} is written first, then the int
+     * {@code i[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param i an array of <code>int</code>s to be written.
+     * @param i an array of {@code int}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>int</code>s to write.
+     * @param len the number of {@code int}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>i.length</code>.
-     * @exception NullPointerException if <code>i</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code i.length}.
+     * @exception NullPointerException if {@code i} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeInts(int[] i, int off, int len) throws IOException;
 
     /**
      * Writes a sequence of longs to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The long <code>l[off]</code> is written first, then the long
-     * <code>l[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The long {@code l[off]} is written first, then the long
+     * {@code l[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param l an array of <code>long</code>s to be written.
+     * @param l an array of {@code long}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>long</code>s to write.
+     * @param len the number of {@code long}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>l.length</code>.
-     * @exception NullPointerException if <code>l</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code l.length}.
+     * @exception NullPointerException if {@code l} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeLongs(long[] l, int off, int len) throws IOException;
 
     /**
      * Writes a sequence of floats to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The float <code>f[off]</code> is written first, then the float
-     * <code>f[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The float {@code f[off]} is written first, then the float
+     * {@code f[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param f an array of <code>float</code>s to be written.
+     * @param f an array of {@code float}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>float</code>s to write.
+     * @param len the number of {@code float}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>f.length</code>.
-     * @exception NullPointerException if <code>f</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code f.length}.
+     * @exception NullPointerException if {@code f} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeFloats(float[] f, int off, int len) throws IOException;
 
     /**
      * Writes a sequence of doubles to the stream at the current
-     * position.  If <code>len</code> is 0, nothing is written.
-     * The double <code>d[off]</code> is written first, then the double
-     * <code>d[off + 1]</code>, and so on.  The byte order of the
+     * position.  If {@code len} is 0, nothing is written.
+     * The double {@code d[off]} is written first, then the double
+     * {@code d[off + 1]}, and so on.  The byte order of the
      * stream is used to determine the order in which the individual
      * bytes are written.
      *
      * <p> If the bit offset within the stream is non-zero, the
      * remainder of the current byte is padded with 0s
      * and written out first.  The bit offset will be 0 after the
      * write.
      *
-     * @param d an array of <code>doubles</code>s to be written.
+     * @param d an array of {@code doubles}s to be written.
      * @param off the start offset in the data.
-     * @param len the number of <code>double</code>s to write.
+     * @param len the number of {@code double}s to write.
      *
-     * @exception IndexOutOfBoundsException if <code>off</code> is
-     * negative, <code>len</code> is negative, or <code>off +
-     * len</code> is greater than <code>d.length</code>.
-     * @exception NullPointerException if <code>d</code> is
-     * <code>null</code>.
+     * @exception IndexOutOfBoundsException if {@code off} is
+     * negative, {@code len} is negative, or {@code off + len}
+     * is greater than {@code d.length}.
+     * @exception NullPointerException if {@code d} is
+     * {@code null}.
      * @exception IOException if an I/O error occurs.
      */
     void writeDoubles(double[] d, int off, int len) throws IOException;
 
     /**

@@ -601,61 +601,61 @@
      *
      * <p> If any bits of a particular byte have never been set
      * at the time the byte is flushed to the destination, those
      * bits will be set to 0 automatically.
      *
-     * @param bit an <code>int</code> whose least significant bit
+     * @param bit an {@code int} whose least significant bit
      * is to be written to the stream.
      *
      * @exception IOException if an I/O error occurs.
      */
     void writeBit(int bit) throws IOException;
 
     /**
-     * Writes a sequence of bits, given by the <code>numBits</code>
-     * least significant bits of the <code>bits</code> argument in
+     * Writes a sequence of bits, given by the {@code numBits}
+     * least significant bits of the {@code bits} argument in
      * left-to-right order, to the stream at the current bit offset
-     * within the current byte position.  The upper <code>64 -
-     * numBits</code> bits of the argument are ignored.  The bit
-     * offset is advanced by <code>numBits</code> and reduced modulo
+     * within the current byte position.  The upper {@code 64 - numBits}
+     * bits of the argument are ignored.  The bit
+     * offset is advanced by {@code numBits} and reduced modulo
      * 8.  Note that a bit offset of 0 always indicates the
      * most-significant bit of the byte, and bytes of bits are written
      * out in sequence as they are encountered.  Thus bit writes are
      * always effectively in network byte order.  The actual stream
      * byte order setting is ignored.
      *
      * <p> Bit data may be accumulated in memory indefinitely, until
-     * <code>flushBefore</code> is called.  At that time, all bit data
+     * {@code flushBefore} is called.  At that time, all bit data
      * prior to the flushed position will be written.
      *
      * <p> If any bits of a particular byte have never been set
      * at the time the byte is flushed to the destination, those
      * bits will be set to 0 automatically.
      *
-     * @param bits a <code>long</code> containing the bits to be
-     * written, starting with the bit in position <code>numBits -
-     * 1</code> down to the least significant bit.
+     * @param bits a {@code long} containing the bits to be
+     * written, starting with the bit in position {@code numBits - 1}
+     * down to the least significant bit.
      *
-     * @param numBits an <code>int</code> between 0 and 64, inclusive.
+     * @param numBits an {@code int} between 0 and 64, inclusive.
      *
-     * @exception IllegalArgumentException if <code>numBits</code> is
+     * @exception IllegalArgumentException if {@code numBits} is
      * not between 0 and 64, inclusive.
      * @exception IOException if an I/O error occurs.
      */
     void writeBits(long bits, int numBits) throws IOException;
 
     /**
      * Flushes all data prior to the given position to the underlying
-     * destination, such as an <code>OutputStream</code> or
-     * <code>File</code>.  Attempting to seek to the flushed portion
+     * destination, such as an {@code OutputStream} or
+     * {@code File}.  Attempting to seek to the flushed portion
      * of the stream will result in an
-     * <code>IndexOutOfBoundsException</code>.
+     * {@code IndexOutOfBoundsException}.
      *
-     * @param pos a <code>long</code> containing the length of the
+     * @param pos a {@code long} containing the length of the
      * stream prefix that may be flushed to the destination.
      *
-     * @exception IndexOutOfBoundsException if <code>pos</code> lies
+     * @exception IndexOutOfBoundsException if {@code pos} lies
      * in the flushed portion of the stream or past the current stream
      * position.
      * @exception IOException if an I/O error occurs.
      */
     void flushBefore(long pos) throws IOException;
< prev index next >