Applications that need to define a subclass of InputStream
+ *
Applications that need to define a subclass of {@code InputStream}
* must always provide a method that returns the next byte of input.
*
* @author Arthur van Hoff
@@ -167,15 +167,15 @@
/**
* Reads the next byte of data from the input stream. The value byte is
- * returned as an int in the range 0 to
- * 255. If no byte is available because the end of the stream
- * has been reached, the value -1 is returned. This method
+ * returned as an {@code int} in the range {@code 0} to
+ * {@code 255}. If no byte is available because the end of the 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.
*
*
A subclass must provide an implementation of this method.
*
- * @return the next byte of data, or -1 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.
*/
@@ -183,35 +183,35 @@
/**
* Reads some number of bytes from the input stream and stores them into
- * the buffer array b. The number of bytes actually read is
+ * the buffer array {@code b}. The number of bytes actually read is
* returned as an integer. This method blocks until input data is
* available, end of file is detected, or an exception is thrown.
*
- *
If the length of b is zero, then no bytes are read and
- * 0 is returned; otherwise, there is an attempt to read at
+ *
If the length of {@code b} is zero, then no bytes are read and
+ * {@code 0} is returned; otherwise, there is an attempt to read at
* least one byte. If no byte is available because the stream is at the
- * end of the file, the value -1 is returned; otherwise, at
- * least one byte is read and stored into b.
+ * end of the file, the value {@code -1} is returned; otherwise, at
+ * least one byte is read and stored into {@code b}.
*
- *
The first byte read is stored into element b[0], the
- * next one into b[1], and so on. The number of bytes read is,
- * at most, equal to the length of b. Let k be the
+ *
The first byte read is stored into element {@code b[0]}, the
+ * next one into {@code b[1]}, and so on. The number of bytes read is,
+ * at most, equal to the length of {@code b}. Let k be the
* number of bytes actually read; these bytes will be stored in elements
- * b[0] through b[k-1],
- * leaving elements b[k] through
- * b[b.length-1] unaffected.
+ * {@code b[0]} through {@code b[}k{@code -1]},
+ * leaving elements {@code b[}k{@code ]} through
+ * {@code b[b.length-1]} unaffected.
*
- *
The read(b) method for class InputStream
- * has the same effect as:
read(b, 0, b.length) The {@code read(b)} method for class {@code InputStream} + * has the same effect as:
{@code read(b, 0, b.length) }
*
* @param b the buffer into which the data is read.
* @return the total number of bytes read into the buffer, or
- * -1 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 IOException If the first byte cannot be read for any reason
* other than the end of the file, if the input stream has been
* closed, or if some other I/O error occurs.
- * @throws NullPointerException if b is null.
+ * @throws NullPointerException if {@code b} is {@code null}.
* @see java.io.InputStream#read(byte[], int, int)
*/
public int read(byte b[]) throws IOException {
@@ -219,60 +219,60 @@
}
/**
- * Reads up to len bytes of data from the input stream into
+ * Reads up to {@code len} bytes of data from the input stream into
* an array of bytes. An attempt is made to read as many as
- * len bytes, but a smaller number may be read.
+ * {@code len} bytes, but a smaller number may be read.
* The number of bytes actually read is returned as an integer.
*
* This method blocks until input data is available, end of file is * detected, or an exception is thrown. * - *
If len is zero, then no bytes are read and
- * 0 is returned; otherwise, there is an attempt to read at
+ *
If {@code len} is zero, then no bytes are read and
+ * {@code 0} is returned; otherwise, there is an attempt to read at
* least one byte. If no byte is available because the stream is at end of
- * file, the value -1 is returned; otherwise, at least one
- * byte is read and stored into b.
+ * file, the value {@code -1} is returned; otherwise, at least one
+ * byte is read and stored into {@code b}.
*
- *
The first byte read is stored into element b[off], the
- * next one into b[off+1], and so on. The number of bytes read
- * is, at most, equal to len. Let k be the number of
+ *
The first byte read is stored into element {@code b[off]}, the
+ * next one into {@code b[off+1]}, and so on. The number of bytes read
+ * is, at most, equal to {@code len}. Let k be the number of
* bytes actually read; these bytes will be stored in elements
- * b[off] through b[off+k-1],
- * leaving elements b[off+k] through
- * b[off+len-1] unaffected.
+ * {@code b[off]} through {@code b[off+}k{@code -1]},
+ * leaving elements {@code b[off+}k{@code ]} through
+ * {@code b[off+len-1]} unaffected.
*
- *
In every case, elements b[0] through
- * b[off-1] and elements b[off+len] through
- * b[b.length-1] are unaffected.
+ *
In every case, elements {@code b[0]} through + * {@code b[off-1]} and elements {@code b[off+len]} through + * {@code b[b.length-1]} are unaffected. * - *
The read(b, off, len) method
- * for class InputStream simply calls the method
- * read() repeatedly. If the first such call results in an
- * IOException, that exception is returned from the call to
- * the read(b, off, len) method. If
- * any subsequent call to read() results in a
- * IOException, the exception is caught and treated as if it
+ *
The {@code read(b, off, len)} method
+ * for class {@code InputStream} simply calls the method
+ * {@code read()} repeatedly. If the first such call results in an
+ * {@code IOException}, that exception is returned from the call to
+ * the {@code read(b,} {@code off,} {@code len)} method. If
+ * any subsequent call to {@code read()} results in a
+ * {@code IOException}, the exception is caught and treated as if it
* were end of file; the bytes read up to that point are stored into
- * b and the number of bytes read before the exception
+ * {@code b} and the number of bytes read before the exception
* occurred is returned. The default implementation of this method blocks
- * until the requested amount of input data len has been read,
+ * until the requested amount of input data {@code len} has been read,
* end of file is detected, or an exception is thrown. Subclasses are
* encouraged to provide a more efficient implementation of this method.
*
* @param b the buffer into which the data is read.
- * @param off the start offset in array b
+ * @param off the start offset in array {@code b}
* at which the data is written.
* @param len the maximum number of bytes to read.
* @return the total number of bytes read into the buffer, or
- * -1 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 IOException If the first byte cannot be read for any reason
* other than end of file, or if the input stream has been closed,
* or if some other I/O error occurs.
- * @throws NullPointerException If b is null.
- * @throws IndexOutOfBoundsException If off is negative,
- * len is negative, or len is greater than
- * b.length - off
+ * @throws NullPointerException If {@code b} is {@code null}.
+ * @throws IndexOutOfBoundsException If {@code off} is negative,
+ * {@code len} is negative, or {@code len} is greater than
+ * {@code b.length - off}
* @see java.io.InputStream#read()
*/
public int read(byte b[], int off, int len) throws IOException {
@@ -509,18 +509,18 @@
}
/**
- * Skips over and discards n bytes of data from this input
- * stream. The skip method may, for a variety of reasons, end
- * up skipping over some smaller number of bytes, possibly 0.
+ * Skips over and discards {@code n} bytes of data from this input
+ * stream. The {@code skip} method may, for a variety of reasons, end
+ * up skipping over some smaller number of bytes, possibly {@code 0}.
* This may result from any of a number of conditions; reaching end of file
- * before n bytes have been skipped is only one possibility.
+ * before {@code n} bytes have been skipped is only one possibility.
* The actual number of bytes skipped is returned. If {@code n} is
* negative, the {@code skip} method for class {@code InputStream} always
* returns 0, and no bytes are skipped. Subclasses may handle the negative
* value differently.
*
- *
The skip method implementation of this class creates a
- * byte array and then repeatedly reads into it until n bytes
+ *
The {@code skip} method implementation of this class creates a + * byte array and then repeatedly reads into it until {@code n} bytes * have been read or the end of the stream has been reached. Subclasses are * encouraged to provide a more efficient implementation of this method. * For instance, the implementation may depend on the ability to seek. @@ -644,7 +644,7 @@ * Closes this input stream and releases any system resources associated * with the stream. * - *
The close method of InputStream does
+ *
The {@code close} method of {@code InputStream} does
* nothing.
*
* @throws IOException if an I/O error occurs.
@@ -653,24 +653,24 @@
/**
* Marks the current position in this input stream. A subsequent call to
- * the reset method repositions this stream at the last marked
+ * the {@code reset} method repositions this stream at the last marked
* position so that subsequent reads re-read the same bytes.
*
- *
The readlimit arguments tells this input stream to
+ *
The {@code readlimit} arguments tells this input stream to * allow that many bytes to be read before the mark position gets * invalidated. * - *
The general contract of mark is that, if the method
- * markSupported returns true, the stream somehow
- * remembers all the bytes read after the call to mark and
+ *
The general contract of {@code mark} is that, if the method
+ * {@code markSupported} returns {@code true}, the stream somehow
+ * remembers all the bytes read after the call to {@code mark} and
* stands ready to supply those same bytes again if and whenever the method
- * reset is called. However, the stream is not required to
- * remember any data at all if more than readlimit bytes are
- * read from the stream before reset is called.
+ * {@code reset} is called. However, the stream is not required to
+ * remember any data at all if more than {@code readlimit} bytes are
+ * read from the stream before {@code reset} is called.
*
*
Marking a closed stream should not have any effect on the stream. * - *
The mark method of InputStream does
+ *
The {@code mark} method of {@code InputStream} does
* nothing.
*
* @param readlimit the maximum limit of bytes that can be read before
@@ -681,42 +681,42 @@
/**
* Repositions this stream to the position at the time the
- * mark method was last called on this input stream.
+ * {@code mark} method was last called on this input stream.
*
- *
The general contract of reset is:
+ *
The general contract of {@code reset} is: * *
markSupported returns
- * true, then:
+ * mark has not been called since
+ * mark was last called is larger than the argument
- * to mark at that last call, then an
- * IOException might be thrown.
+ * since {@code mark} was last called is larger than the argument
+ * to {@code mark} at that last call, then an
+ * {@code IOException} might be thrown.
*
- * IOException is not thrown, then the
+ * mark (or since the start of the
- * file, if mark has not been called) will be resupplied
- * to subsequent callers of the read method, followed by
+ * most recent call to {@code mark} (or since the start of the
+ * file, if {@code mark} has not been called) will be resupplied
+ * to subsequent callers of the {@code read} method, followed by
* any bytes that otherwise would have been the next input data as of
- * the time of the call to reset. markSupported returns
- * false, then:
+ * reset may throw an
- * IOException.
+ * IOException is not thrown, then the stream
+ * read method depend on the
+ * to subsequent callers of the {@code read} method depend on the
* particular type of the input stream. The method reset for class InputStream
- * does nothing except throw an IOException.
+ *
The method {@code reset} for class {@code InputStream}
+ * does nothing except throw an {@code IOException}.
*
* @throws IOException if this stream has not been marked or if the
* mark has been invalidated.
@@ -728,14 +728,14 @@
}
/**
- * Tests if this input stream supports the mark and
- * reset methods. Whether or not mark and
- * reset are supported is an invariant property of a
- * particular input stream instance. The markSupported method
- * of InputStream returns false.
+ * Tests if this input stream supports the {@code mark} and
+ * {@code reset} methods. Whether or not {@code mark} and
+ * {@code reset} are supported is an invariant property of a
+ * particular input stream instance. The {@code markSupported} method
+ * of {@code InputStream} returns {@code false}.
*
- * @return true if this stream instance supports the mark
- * and reset methods; false otherwise.
+ * @return {@code true} if this stream instance supports the mark
+ * and reset methods; {@code false} otherwise.
* @see java.io.InputStream#mark(int)
* @see java.io.InputStream#reset()
*/