< prev index next >
src/java.desktop/share/classes/javax/imageio/stream/ImageInputStreamImpl.java
Print this page
@@ -31,11 +31,11 @@
import java.nio.ByteOrder;
import java.util.Stack;
import javax.imageio.IIOException;
/**
- * An abstract class implementing the <code>ImageInputStream</code> interface.
+ * An abstract class implementing the {@code ImageInputStream} interface.
* This class is designed to reduce the number of methods that must
* be implemented by subclasses.
*
* <p> In particular, this class handles most or all of the details of
* byte order interpretation, buffering, mark/reset, discarding,
@@ -61,15 +61,15 @@
*/
byte[] byteBuf = new byte[BYTE_BUF_LENGTH];
/**
* The byte order of the stream as an instance of the enumeration
- * class <code>java.nio.ByteOrder</code>, where
- * <code>ByteOrder.BIG_ENDIAN</code> indicates network byte order
- * and <code>ByteOrder.LITTLE_ENDIAN</code> indicates the reverse
+ * class {@code java.nio.ByteOrder}, where
+ * {@code ByteOrder.BIG_ENDIAN} indicates network byte order
+ * and {@code ByteOrder.LITTLE_ENDIAN} indicates the reverse
* order. By default, the value is
- * <code>ByteOrder.BIG_ENDIAN</code>.
+ * {@code ByteOrder.BIG_ENDIAN}.
*/
protected ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
/**
* The current read position within the stream. Subclasses are
@@ -85,23 +85,23 @@
*/
protected int bitOffset;
/**
* The position prior to which data may be discarded. Seeking
- * to a smaller position is not allowed. <code>flushedPos</code>
+ * to a smaller position is not allowed. {@code flushedPos}
* will always be {@literal >= 0}.
*/
protected long flushedPos = 0;
/**
- * Constructs an <code>ImageInputStreamImpl</code>.
+ * Constructs an {@code ImageInputStreamImpl}.
*/
public ImageInputStreamImpl() {
}
/**
- * Throws an <code>IOException</code> if the stream has been closed.
+ * Throws an {@code IOException} if the stream has been closed.
* Subclasses may call this method from any of their methods that
* require the stream not to be closed.
*
* @exception IOException if the stream is closed.
*/
@@ -119,69 +119,69 @@
return byteOrder;
}
/**
* Reads a single byte from the stream and returns it as an
- * <code>int</code> between 0 and 255. If EOF is reached,
- * <code>-1</code> is returned.
+ * {@code int} between 0 and 255. If EOF is reached,
+ * {@code -1} is returned.
*
* <p> Subclasses must provide an implementation for this method.
* The subclass implementation should update the stream position
* before exiting.
*
* <p> The bit offset within the stream must be reset to zero before
* the read occurs.
*
- * @return the value of the next byte in the stream, or <code>-1</code>
+ * @return the value of the next byte in the stream, or {@code -1}
* if EOF is reached.
*
* @exception IOException if the stream has been closed.
*/
public abstract int read() throws IOException;
/**
- * A convenience method that calls <code>read(b, 0, b.length)</code>.
+ * A convenience method that calls {@code read(b, 0, b.length)}.
*
* <p> The bit offset within the stream is reset to zero before
* the read occurs.
*
- * @return the number of bytes actually read, or <code>-1</code>
+ * @return the number of bytes actually read, or {@code -1}
* to indicate EOF.
*
- * @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.
*/
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
/**
- * Reads up to <code>len</code> bytes from the stream, and stores
- * them into <code>b</code> starting at index <code>off</code>.
+ * Reads up to {@code len} bytes from the stream, and stores
+ * them into {@code b} starting at index {@code off}.
* If no bytes can be read because the end of the stream has been
- * reached, <code>-1</code> is returned.
+ * reached, {@code -1} is returned.
*
* <p> The bit offset within the stream must be reset to zero before
* the read occurs.
*
* <p> Subclasses must provide an implementation for this method.
* The subclass implementation should update the stream position
* before exiting.
*
* @param b an array of bytes to be written to.
- * @param off the starting position within <code>b</code> to write to.
+ * @param off the starting position within {@code b} to write to.
* @param len the maximum number of bytes to read.
*
- * @return the number of bytes actually read, or <code>-1</code>
+ * @return the number of bytes actually read, or {@code -1}
* to indicate EOF.
*
- * @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.
*/
public abstract int read(byte[] b, int off, int len) throws IOException;
public void readBytes(IIOByteBuffer buf, int len) throws IOException {
@@ -706,11 +706,11 @@
return accum;
}
/**
- * Returns <code>-1L</code> to indicate that the stream has unknown
+ * Returns {@code -1L} to indicate that the stream has unknown
* length. Subclasses must override this method to provide actual
* length information.
*
* @return -1L to indicate unknown length.
*/
@@ -718,42 +718,42 @@
return -1L;
}
/**
* Advances the current stream position by calling
- * <code>seek(getStreamPosition() + n)</code>.
+ * {@code seek(getStreamPosition() + n)}.
*
* <p> The bit offset is reset to zero.
*
* @param n the number of bytes to seek forward.
*
- * @return an <code>int</code> representing the number of bytes
+ * @return an {@code int} representing the number of bytes
* skipped.
*
- * @exception IOException if <code>getStreamPosition</code>
- * throws an <code>IOException</code> when computing either
+ * @exception IOException if {@code getStreamPosition}
+ * throws an {@code IOException} when computing either
* the starting or ending position.
*/
public int skipBytes(int n) throws IOException {
long pos = getStreamPosition();
seek(pos + n);
return (int)(getStreamPosition() - pos);
}
/**
* Advances the current stream position by calling
- * <code>seek(getStreamPosition() + n)</code>.
+ * {@code seek(getStreamPosition() + n)}.
*
* <p> The bit offset is reset to zero.
*
* @param n the number of bytes to seek forward.
*
- * @return a <code>long</code> representing the number of bytes
+ * @return a {@code long} representing the number of bytes
* skipped.
*
- * @exception IOException if <code>getStreamPosition</code>
- * throws an <code>IOException</code> when computing either
+ * @exception IOException if {@code getStreamPosition}
+ * throws an {@code IOException} when computing either
* the starting or ending position.
*/
public long skipBytes(long n) throws IOException {
long pos = getStreamPosition();
seek(pos + n);
@@ -786,11 +786,11 @@
/**
* Resets the current stream byte and bit positions from the stack
* of marked positions.
*
- * <p> An <code>IOException</code> will be thrown if the previous
+ * <p> An {@code IOException} will be thrown if the previous
* marked position lies in the discarded portion of the stream.
*
* @exception IOException if an I/O error occurs.
*/
public void reset() throws IOException {
@@ -859,11 +859,11 @@
isClosed = true;
}
/**
* Finalizes this object prior to garbage collection. The
- * <code>close</code> method is called to close any open input
+ * {@code close} method is called to close any open input
* source. This method should not be called from application
* code.
*
* @exception Throwable if an error occurs during superclass
* finalization.
< prev index next >