org.apache.xmlgraphics.image.codec.util.SeekableStream Maven / Gradle / Ivy
Show all versions of xmlgraphics-commons Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: SeekableStream.java 1732018 2016-02-24 04:51:06Z gadams $ */
package org.apache.xmlgraphics.image.codec.util;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
/**
* An abstract subclass of 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.
*
*
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 FileSeekableStream 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.
*
*/
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, shared by {@link ForwardSeekableStream} */
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(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 = (ruileBuf[0] & 0xff);
long ch2 = (ruileBuf[1] & 0xff);
long ch3 = (ruileBuf[2] & 0xff);
long ch4 = (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) {
c = read();
switch (c) {
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 java.io.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();
}
}