java.io.InputStream that
* allows seeking within the input, similar to the
* RandomAccessFile class. Additionally, the
* DataInput interface is supported and extended to
* include support for little-endian representations of fundamental
* data types.
*
* In addition to the familiar methods from
* InputStream, the methods
* getFilePointer(), seek(), are defined as
* in the RandomAccessFile class. The
* canSeekBackwards() method will return
* true if it is permissible to seek to a position
* earlier in the stream than the current value of
* getFilePointer(). Some subclasses of
* SeekableStream guarantee the ability to seek backwards
* while others may not offer this feature in the interest of
* providing greater efficiency for those users who do not require it.
*
*
The DataInput interface is supported as well.
* This included the skipBytes() and
* readFully() methods and a variety of read
* methods for various data types.
*
*
A number of concrete subclasses of SeekableStream
* are supplied in the com.sun.media.jai.codec package.
*
*
Three classes are provided for the purpose of adapting a
* standard InputStream to the
* SeekableStream interface.
* ForwardSeekableStream does not allows seeking
* backwards, but is inexpensive to use.
* FileCacheSeekableStream maintains a copy of all of the
* data read from the input in a temporary file; this file will be
* discarded automatically when the FileCacheSeekableStream is
* finalized, or when the JVM exits normally.
* FileCacheSeekableStream is intended to be reasonably
* efficient apart from the unavoidable use of disk space. In
* circumstances where the creation of a temporary file is not
* possible, MemoryCacheSeekableStream may be used.
* MemoryCacheSeekableStream creates a potentially large
* in-memory buffer to store the stream data and so should be
* avoided when possible.
*
*
The FileSeekableStream class wraps a
* File or RandomAccessFile. It forwards
* requests to the real underlying file. It performs a limited amount
* of caching in order to avoid excessive I/O costs.
*
*
The SegmentedSeekableStream class performs a
* different sort of function. It creates a
* SeekableStream from another
* SeekableStream by selecting a series of portions or
* "segments". Each segment starts at a specified location within the
* source SeekableStream and extends for a specified
* number of bytes. The StreamSegmentMapper interface
* and StreamSegment class may be
* used to compute the segment positions dynamically.
*
*
A convenience methods, wrapInputStream is provided
* to construct a suitable SeekableStream instance whose
* data is supplied by a given InputStream. The caller,
* by means of the canSeekBackwards parameter, determines
* whether support for seeking backwards is required.
*
* @see java.io.DataInput
* @see java.io.InputStream
* @see java.io.RandomAccessFile
* @see ByteArraySeekableStream
* @see FileCacheSeekableStream
* @see FileSeekableStream
* @see ForwardSeekableStream
* @see MemoryCacheSeekableStream
* @see SegmentedSeekableStream
* @see StreamSegment
* @see StreamSegmentMapper
*
*
This class is not a committed part of the JAI API. It may
* be removed or changed in future releases of JAI.
*/
public abstract class SeekableStream
extends InputStream
implements DataInput {
/**
* Returns a SeekableStream that will read from a
* given InputStream, optionally including support
* for seeking backwards. This is a convenience method that
* avoids the need to instantiate specific subclasses of
* SeekableStream depending on the current security
* model.
*
* @param is An InputStream.
* @param canSeekBackwards true if the ability to seek
* backwards in the output is required.
* @return An instance of SeekableStream.
*/
public static SeekableStream wrapInputStream(InputStream is,
boolean canSeekBackwards) {
SeekableStream stream = null;
if (canSeekBackwards) {
try {
stream = new FileCacheSeekableStream(is);
} catch (Exception e) {
stream = new MemoryCacheSeekableStream(is);
}
} else {
stream = new ForwardSeekableStream(is);
}
return stream;
}
// Methods from InputStream
/**
* 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
* 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
* stream is reached.
* @exception IOException if an I/O error occurs.
*/
public abstract int read() throws IOException;
/**
* Reads up to 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, possibly
* zero. The number of bytes actually read is returned as an integer.
*
*
This method blocks until input data is available, end of stream is * detected, or an exception is thrown. * *
If b is null, a
* NullPointerException is thrown.
*
*
If off is negative, or len is negative, or
* off+len is greater than the length of the array
* b, then an IndexOutOfBoundsException is
* thrown.
*
*
If len is zero, then no bytes are read and
* 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
* stream, the value -1 is returned; otherwise, at least one
* byte is read and stored into 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
* 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.
*
*
In every case, elements b[0] through
* b[off] and elements b[off+len] through
* b[b.length-1] are unaffected.
*
*
If the first byte cannot be read for any reason other than end of
* stream, then an IOException is thrown. In particular, an
* IOException is thrown if the input stream has been closed.
*
*
A subclass must provide an implementation of this method.
*
* @param b the buffer into which the data is read.
* @param off the start offset in array 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
* the stream has been reached.
* @exception IOException if an I/O error occurs.
*/
public abstract int read(byte[] b, int off, int len) throws IOException;
// Implemented in InputStream:
//
// public int read(byte[] b) throws IOException {
// public long skip(long n) throws IOException
// public int available) throws IOException
// public void close() throws IOException;
/** Marked position */
protected long markPos = -1L;
/**
* Marks the current file position for later return using
* the reset() method.
*/
public synchronized void mark(int readLimit) {
try {
markPos = getFilePointer();
} catch (IOException e) {
markPos = -1L;
}
}
/**
* Returns the file position to its position at the time of
* the immediately previous call to the mark()
* method.
*/
public synchronized void reset() throws IOException {
if (markPos != -1) {
seek(markPos);
}
}
/**
* Returns true if marking is supported.
* Marking is automatically supported for SeekableStream
* subclasses that support seeking backeards. Subclasses that do
* not support seeking backwards but do support marking must override
* this method.
*/
public boolean markSupported() {
return canSeekBackwards();
}
/**
* Returns true if this object supports calls to
* seek(pos) with an offset pos smaller
* than the current offset, as returned by getFilePointer.
*/
public boolean canSeekBackwards() {
return false;
}
/**
* Returns the current offset in this stream.
*
* @return the offset from the beginning of the stream, in bytes,
* at which the next read occurs.
* @exception IOException if an I/O error occurs.
*/
public abstract long getFilePointer() throws IOException;
/**
* Sets the offset, measured from the beginning of this
* stream, at which the next read occurs.
*
*
If canSeekBackwards() returns false,
* then setting pos to an offset smaller than
* the current value of getFilePointer() will have
* no effect.
*
* @param pos the offset position, measured in bytes from the
* beginning of the stream, at which to set the stream
* pointer.
* @exception IOException if pos is less than
* 0 or if an I/O error occurs.
*/
public abstract void seek(long pos) throws IOException;
// Methods from RandomAccessFile
/**
* Reads b.length bytes from this stream into the byte
* array, starting at the current stream pointer. This method reads
* repeatedly from the stream until the requested number of bytes are
* read. This method blocks until the requested number of bytes are
* read, the end of the stream is detected, or an exception is thrown.
*
* @param b the buffer into which the data is read.
* @exception EOFException if this stream reaches the end before reading
* all the bytes.
* @exception IOException if an I/O error occurs.
*/
public final void readFully(byte[] b) throws IOException {
readFully(b, 0, b.length);
}
/**
* Reads exactly len bytes from this stream into the byte
* array, starting at the current stream pointer. This method reads
* repeatedly from the stream until the requested number of bytes are
* read. This method blocks until the requested number of bytes are
* read, the end of the stream is detected, or an exception is thrown.
*
* @param b the buffer into which the data is read.
* @param off the start offset of the data.
* @param len the number of bytes to read.
* @exception EOFException if this stream reaches the end before reading
* all the bytes.
* @exception IOException if an I/O error occurs.
*/
public final void readFully(byte[] b, int off, int len)
throws IOException {
int n = 0;
do {
int count = this.read(b, off + n, len - n);
if (count < 0)
throw new EOFException();
n += count;
} while (n < len);
}
// Methods from DataInput, plus little-endian versions
/**
* Attempts to skip over n bytes of input discarding the
* skipped bytes.
*
*
* This method may skip over some smaller number of bytes, possibly zero.
* This may result from any of a number of conditions; reaching end of
* stream before n bytes have been skipped is only one
* possibility. This method never throws an EOFException.
* The actual number of bytes skipped is returned. If n
* is negative, no bytes are skipped.
*
* @param n the number of bytes to be skipped.
* @return the actual number of bytes skipped.
* @exception IOException if an I/O error occurs.
*/
public int skipBytes(int n) throws IOException {
if (n <= 0) {
return 0;
}
return (int)skip((long)n);
}
/**
* Reads a boolean from this stream. This method reads a
* single byte from the stream, starting at the current stream pointer.
* A value of 0 represents
* false. Any other value represents true.
* This method blocks until the byte is read, the end of the stream
* is detected, or an exception is thrown.
*
* @return the boolean value read.
* @exception EOFException if this stream has reached the end.
* @exception IOException if an I/O error occurs.
*/
public final boolean readBoolean() throws IOException {
int ch = this.read();
if (ch < 0)
throw new EOFException();
return (ch != 0);
}
/**
* Reads a signed eight-bit value from this stream. This method reads a
* byte from the stream, starting from the current stream pointer.
* If the byte read is b, where
* 0 <= b <= 255,
* then the result is:
*
* (byte)(b)
*
* This method blocks until the byte is read, the end of the stream
* is detected, or an exception is thrown.
*
* @return the next byte of this stream as a signed eight-bit
* byte.
* @exception EOFException if this stream has reached the end.
* @exception IOException if an I/O error occurs.
*/
public final byte readByte() throws IOException {
int ch = this.read();
if (ch < 0)
throw new EOFException();
return (byte)(ch);
}
/**
* Reads an unsigned eight-bit number from this stream. This method reads
* a byte from this stream, starting at the current stream pointer,
* and returns that byte.
*
* This method blocks until the byte is read, the end of the stream
* is detected, or an exception is thrown.
*
* @return the next byte of this stream, interpreted as an unsigned
* eight-bit number.
* @exception EOFException if this stream has reached the end.
* @exception IOException if an I/O error occurs.
*/
public final int readUnsignedByte() throws IOException {
int ch = this.read();
if (ch < 0)
throw new EOFException();
return ch;
}
/**
* Reads a signed 16-bit number from this stream.
* The method reads two
* bytes from this stream, starting at the current stream pointer.
* If the two bytes read, in order, are
* b1 and b2, where each of the two values is
* between 0 and 255, inclusive, then the
* result is equal to:
*
* (short)((b1 << 8) | b2)
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream, interpreted as a signed
* 16-bit number.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final short readShort() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (short)((ch1 << 8) + (ch2 << 0));
}
/**
* Reads a signed 16-bit number from this stream in little-endian order.
* The method reads two
* bytes from this stream, starting at the current stream pointer.
* If the two bytes read, in order, are
* b1 and b2, where each of the two values is
* between 0 and 255, inclusive, then the
* result is equal to:
*
* (short)((b2 << 8) | b1)
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream, interpreted as a signed
* 16-bit number.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final short readShortLE() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (short)((ch2 << 8) + (ch1 << 0));
}
/**
* Reads an unsigned 16-bit number from this stream. This method reads
* two bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1 and b2, where
* 0 <= b1, b2 <= 255,
* then the result is equal to:
*
* (b1 << 8) | b2
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream, interpreted as an
* unsigned 16-bit integer.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final int readUnsignedShort() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (ch1 << 8) + (ch2 << 0);
}
/**
* Reads an unsigned 16-bit number from this stream in little-endian order.
* This method reads
* two bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1 and b2, where
* 0 <= b1, b2 <= 255,
* then the result is equal to:
*
* (b2 << 8) | b1
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream, interpreted as an
* unsigned 16-bit integer.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final int readUnsignedShortLE() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (ch2 << 8) + (ch1 << 0);
}
/**
* Reads a Unicode character from this stream. This method reads two
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1 and b2, where
* 0 <= b1, b2 <= 255,
* then the result is equal to:
*
* (char)((b1 << 8) | b2)
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream as a Unicode character.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final char readChar() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (char)((ch1 << 8) + (ch2 << 0));
}
/**
* Reads a Unicode character from this stream in little-endian order.
* This method reads two
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1 and b2, where
* 0 <= b1, b2 <= 255,
* then the result is equal to:
*
* (char)((b2 << 8) | b1)
*
* This method blocks until the two bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next two bytes of this stream as a Unicode character.
* @exception EOFException if this stream reaches the end before reading
* two bytes.
* @exception IOException if an I/O error occurs.
*/
public final char readCharLE() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
if ((ch1 | ch2) < 0)
throw new EOFException();
return (char)((ch2 << 8) + (ch1 << 0));
}
/**
* Reads a signed 32-bit integer from this stream. This method reads 4
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are b1,
* b2, b3, and b4, where
* 0 <= b1, b2, b3, b4 <= 255,
* then the result is equal to:
*
* (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as an
* int.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final int readInt() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
int ch3 = this.read();
int ch4 = this.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}
/**
* Reads a signed 32-bit integer from this stream in little-endian order.
* This method reads 4
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are b1,
* b2, b3, and b4, where
* 0 <= b1, b2, b3, b4 <= 255,
* then the result is equal to:
*
* (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as an
* int.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final int readIntLE() throws IOException {
int ch1 = this.read();
int ch2 = this.read();
int ch3 = this.read();
int ch4 = this.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
}
/**
* Reads an unsigned 32-bit integer from this stream. This method reads 4
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are b1,
* b2, b3, and b4, where
* 0 <= b1, b2, b3, b4 <= 255,
* then the result is equal to:
*
* (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as a
* long.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final long readUnsignedInt() throws IOException {
long ch1 = this.read();
long ch2 = this.read();
long ch3 = this.read();
long ch4 = this.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}
private byte[] ruileBuf = new byte[4];
/**
* Reads an unsigned 32-bit integer from this stream in little-endian
* order. This method reads 4
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are b1,
* b2, b3, and b4, where
* 0 <= b1, b2, b3, b4 <= 255,
* then the result is equal to:
*
* (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as a
* long.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final long readUnsignedIntLE() throws IOException {
this.readFully(ruileBuf);
long ch1 = (long)(ruileBuf[0] & 0xff);
long ch2 = (long)(ruileBuf[1] & 0xff);
long ch3 = (long)(ruileBuf[2] & 0xff);
long ch4 = (long)(ruileBuf[3] & 0xff);
return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
}
/**
* Reads a signed 64-bit integer from this stream. This method reads eight
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1, b2, b3,
* b4, b5, b6,
* b7, and b8, where:
*
* 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
* * then the result is equal to: *
* ((long)b1 << 56) + ((long)b2 << 48)
* + ((long)b3 << 40) + ((long)b4 << 32)
* + ((long)b5 << 24) + ((long)b6 << 16)
* + ((long)b7 << 8) + b8
*
* This method blocks until the eight bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next eight bytes of this stream, interpreted as a
* long.
* @exception EOFException if this stream reaches the end before reading
* eight bytes.
* @exception IOException if an I/O error occurs.
*/
public final long readLong() throws IOException {
return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
}
/**
* Reads a signed 64-bit integer from this stream in little-endian
* order. This method reads eight
* bytes from the stream, starting at the current stream pointer.
* If the bytes read, in order, are
* b1, b2, b3,
* b4, b5, b6,
* b7, and b8, where:
*
* 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
* * then the result is equal to: *
* ((long)b1 << 56) + ((long)b2 << 48)
* + ((long)b3 << 40) + ((long)b4 << 32)
* + ((long)b5 << 24) + ((long)b6 << 16)
* + ((long)b7 << 8) + b8
*
* This method blocks until the eight bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next eight bytes of this stream, interpreted as a
* long.
* @exception EOFException if this stream reaches the end before reading
* eight bytes.
* @exception IOException if an I/O error occurs.
*/
public final long readLongLE() throws IOException {
int i1 = readIntLE();
int i2 = readIntLE();
return ((long)i2 << 32) + (i1 & 0xFFFFFFFFL);
}
/**
* Reads a float from this stream. This method reads an
* int value, starting at the current stream pointer,
* as if by the readInt method
* and then converts that int to a float
* using the intBitsToFloat method in class
* Float.
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as a
* float.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
/**
* Reads a float from this stream in little-endian order.
* This method reads an
* int value, starting at the current stream pointer,
* as if by the readInt method
* and then converts that int to a float
* using the intBitsToFloat method in class
* Float.
*
* This method blocks until the four bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next four bytes of this stream, interpreted as a
* float.
* @exception EOFException if this stream reaches the end before reading
* four bytes.
* @exception IOException if an I/O error occurs.
*/
public final float readFloatLE() throws IOException {
return Float.intBitsToFloat(readIntLE());
}
/**
* Reads a double from this stream. This method reads a
* long value, starting at the current stream pointer,
* as if by the readLong method
* and then converts that long to a double
* using the longBitsToDouble method in
* class Double.
*
* This method blocks until the eight bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next eight bytes of this stream, interpreted as a
* double.
* @exception EOFException if this stream reaches the end before reading
* eight bytes.
* @exception IOException if an I/O error occurs.
*/
public final double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
}
/**
* Reads a double from this stream in little-endian order.
* This method reads a
* long value, starting at the current stream pointer,
* as if by the readLong method
* and then converts that long to a double
* using the longBitsToDouble method in
* class Double.
*
* This method blocks until the eight bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return the next eight bytes of this stream, interpreted as a
* double.
* @exception EOFException if this stream reaches the end before reading
* eight bytes.
* @exception IOException if an I/O error occurs.
*/
public final double readDoubleLE() throws IOException {
return Double.longBitsToDouble(readLongLE());
}
/**
* Reads the next line of text from this stream. This method successively
* reads bytes from the stream, starting at the current stream pointer,
* until it reaches a line terminator or the end
* of the stream. Each byte is converted into a character by taking the
* byte's value for the lower eight bits of the character and setting the
* high eight bits of the character to zero. This method does not,
* therefore, support the full Unicode character set.
*
*
A line of text is terminated by a carriage-return character
* ('\r'), a newline character ('\n'), a
* carriage-return character immediately followed by a newline character,
* or the end of the stream. Line-terminating characters are discarded and
* are not included as part of the string returned.
*
*
This method blocks until a newline character is read, a carriage * return and the byte following it are read (to see if it is a newline), * the end of the stream is reached, or an exception is thrown. * * @return the next line of text from this stream, or null if end * of stream is encountered before even one byte is read. * @exception IOException if an I/O error occurs. */ public final String readLine() throws IOException { StringBuffer input = new StringBuffer(); int c = -1; boolean eol = false; while (!eol) { switch (c = read()) { case -1: case '\n': eol = true; break; case '\r': eol = true; long cur = getFilePointer(); if ((read()) != '\n') { seek(cur); } break; default: input.append((char)c); break; } } if ((c == -1) && (input.length() == 0)) { return null; } return input.toString(); } /** * Reads in a string from this stream. The string has been encoded * using a modified UTF-8 format. *
* The first two bytes are read, starting from the current stream
* pointer, as if by
* readUnsignedShort. This value gives the number of
* following bytes that are in the encoded string, not
* the length of the resulting string. The following bytes are then
* interpreted as bytes encoding characters in the UTF-8 format
* and are converted into characters.
*
* This method blocks until all the bytes are read, the end of the
* stream is detected, or an exception is thrown.
*
* @return a Unicode string.
* @exception EOFException if this stream reaches the end before
* reading all the bytes.
* @exception IOException if an I/O error occurs.
* @exception UTFDataFormatException if the bytes do not represent
* valid UTF-8 encoding of a Unicode string.
*/
public final String readUTF() throws IOException {
return DataInputStream.readUTF(this);
}
/**
* Releases any system resources associated with this stream
* by calling the close() method.
*/
protected void finalize() throws Throwable {
super.finalize();
close();
}
}