/* * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.imageio.stream; import java.io.Closeable;import java.io.DataInput;import java.io.IOException;import java.nio.ByteOrder; /** * A seekable input stream interface for use by * <code>ImageReader</code>s. Various input sources, such as * <code>InputStream</code>s and <code>File</code>s, * as well as future fast I/O sources may be "wrapped" by a suitable * implementation of this interface for use by the Image I/O API. * * @see ImageInputStreamImpl * @see FileImageInputStream * @see FileCacheImageInputStream * @see MemoryCacheImageInputStream * */public interface ImageInputStream extends DataInput, Closeable { /** * Sets the desired byte order for future reads of data values * from this stream. For example, the sequence of bytes '0x01 * 0x02 0x03 0x04' if read as a 4-byte integer would have the * value '0x01020304' using network byte order and the value * '0x04030201' under the reverse byte order. * * <p> The enumeration class <code>java.nio.ByteOrder</code> is * used to specify the byte order. A value of * <code>ByteOrder.BIG_ENDIAN</code> specifies so-called * big-endian or network byte order, in which the high-order byte * comes first. Motorola and Sparc processors store data in this * format, while Intel processors store data in the reverse * <code>ByteOrder.LITTLE_ENDIAN</code> order. * * <p> The byte order has no effect on the results returned from * the <code>readBits</code> method (or the value written by * <code>ImageOutputStream.writeBits</code>). * * @param byteOrder one of <code>ByteOrder.BIG_ENDIAN</code> or * <code>java.nio.ByteOrder.LITTLE_ENDIAN</code>, indicating whether * network byte order or its reverse will be used for future * reads. * * @see java.nio.ByteOrder * @see #getByteOrder * @see #readBits(int) */ void setByteOrder(ByteOrder byteOrder); /** * Returns the byte order with which data values will be read from * this stream as an instance of the * <code>java.nio.ByteOrder</code> enumeration. * * @return one of <code>ByteOrder.BIG_ENDIAN</code> or * <code>ByteOrder.LITTLE_ENDIAN</code>, indicating which byte * order is being used. * * @see java.nio.ByteOrder * @see #setByteOrder */ ByteOrder getByteOrder(); /** * Reads a single byte from the stream and returns it as an * integer between 0 and 255. If the end of the stream is * reached, -1 is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a byte value from the stream, as an int, or -1 to * indicate EOF. * * @exception IOException if an I/O error occurs. */ int read() throws IOException; /** * Reads up to <code>b.length</code> bytes from the stream, and * stores them into <code>b</code> starting at index 0. The * number of bytes read is returned. If no bytes can be read * because the end of the stream has been reached, -1 is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param b an array of bytes to be written to. * * @return the number of bytes actually read, or <code>-1</code> * to indicate EOF. * * @exception NullPointerException if <code>b</code> is * <code>null</code>. * * @exception IOException if an I/O error occurs. */ int read(byte[] b) throws IOException; /** * Reads up to <code>len</code> bytes from the stream, and stores * them into <code>b</code> starting at index <code>off</code>. * The number of bytes read is returned. If no bytes can be read * because the end of the stream has been reached, <code>-1</code> * is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param b an array of bytes to be written to. * @param off the starting position within <code>b</code> to write to. * @param len the maximum number of <code>byte</code>s to read. * * @return the number of bytes actually read, or <code>-1</code> * to indicate EOF. * * @exception NullPointerException if <code>b</code> is * <code>null</code>. * @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 IOException if an I/O error occurs. */ int read(byte[] b, int off, int len) throws IOException; /** * Reads up to <code>len</code> bytes from the stream, and * modifies the supplied <code>IIOByteBuffer</code> to indicate * the byte array, offset, and length where the data may be found. * The caller should not attempt to modify the data found in the * <code>IIOByteBuffer</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param buf an IIOByteBuffer object to be modified. * @param len the maximum number of <code>byte</code>s to read. * * @exception IndexOutOfBoundsException if <code>len</code> is * negative. * @exception NullPointerException if <code>buf</code> is * <code>null</code>. * * @exception IOException if an I/O error occurs. */ void readBytes(IIOByteBuffer buf, int len) throws IOException; /** * Reads a byte from the stream and returns a <code>boolean</code> * value of <code>true</code> if it is nonzero, <code>false</code> * if it is zero. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a boolean value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ boolean readBoolean() throws IOException; /** * Reads a byte from the stream and returns it as a * <code>byte</code> value. Byte values between <code>0x00</code> * and <code>0x7f</code> represent integer values between * <code>0</code> and <code>127</code>. Values between * <code>0x80</code> and <code>0xff</code> represent negative * values from <code>-128</code> to <code>/1</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed byte value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ byte readByte() throws IOException; /** * Reads a byte from the stream, and (conceptually) converts it to * an int, masks it with <code>0xff</code> in order to strip off * any sign-extension bits, and returns it as a <code>byte</code> * value. * * <p> Thus, byte values between <code>0x00</code> and * <code>0x7f</code> are simply returned as integer values between * <code>0</code> and <code>127</code>. Values between * <code>0x80</code> and <code>0xff</code>, which normally * represent negative <code>byte</code>values, will be mapped into * positive integers between <code>128</code> and * <code>255</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned byte value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ int readUnsignedByte() throws IOException; /** * Reads two bytes from the stream, and (conceptually) * concatenates them according to the current byte order, and * returns the result as a <code>short</code> value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed short value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ short readShort() throws IOException; /** * Reads two bytes from the stream, and (conceptually) * concatenates them according to the current byte order, converts * the resulting value to an <code>int</code>, masks it with * <code>0xffff</code> in order to strip off any sign-extension * buts, and returns the result as an unsigned <code>int</code> * value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned short value from the stream, as an int. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ int readUnsignedShort() throws IOException; /** * Equivalent to <code>readUnsignedShort</code>, except that the * result is returned using the <code>char</code> datatype. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned char value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #readUnsignedShort */ char readChar() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as an <code>int</code>. * * <p> The bit offset within the stream is ignored and treated as * though it were zero. * * @return a signed int value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ int readInt() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order, converts the result * to a long, masks it with <code>0xffffffffL</code> in order to * strip off any sign-extension bits, and returns the result as an * unsigned <code>long</code> value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned int value from the stream, as a long. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ long readUnsignedInt() throws IOException; /** * Reads 8 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>long</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed long value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ long readLong() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>float</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a float value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ float readFloat() throws IOException; /** * Reads 8 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>double</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a double value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ double readDouble() throws IOException; /** * Reads the next line of text from the input stream. It reads * successive bytes, converting each byte separately into a * character, until it encounters a line terminator or end of * file; the characters read are then returned as a * <code>String</code>. Note that because this method processes * bytes, it does not support input of the full Unicode character * set. * * <p> If end of file is encountered before even one byte can be * read, then <code>null</code> is returned. Otherwise, each byte * that is read is converted to type <code>char</code> by * zero-extension. If the character <code>'\n'</code> is * encountered, it is discarded and reading ceases. If the * character <code>'\r'</code> is encountered, it is discarded * and, if the following byte converts  to the character * <code>'\n'</code>, then that is discarded also; reading then * ceases. If end of file is encountered before either of the * characters <code>'\n'</code> and <code>'\r'</code> is * encountered, reading ceases. Once reading has ceased, a * <code>String</code> is returned that contains all the * characters read and not discarded, taken in order. Note that * every character in this string will have a value less than * <code>\u0100</code>, that is, <code>(char)256</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a String containing a line of text from the stream. * * @exception IOException if an I/O error occurs. */ String readLine() throws IOException; /** * Reads in a string that has been encoded using a * <a href="../../../java/io/DataInput.html#modified-utf-8">modified * UTF-8</a> * format. The general contract of <code>readUTF</code> is that * it reads a representation of a Unicode character string encoded * in modified UTF-8 format; this string of characters is * then returned as a <code>String</code>. * * <p> First, two bytes are read and used to construct an unsigned * 16-bit integer in the manner of the * <code>readUnsignedShort</code> method, using network byte order * (regardless of the current byte order setting). This integer * value is called the <i>UTF length</i> and specifies the number * of additional bytes to be read. These bytes are then converted * to characters by considering them in groups. The length of each * group is computed from the value of the first byte of the * group. The byte following a group, if any, is the first byte of * the next group. * * <p> If the first byte of a group matches the bit pattern * <code>0xxxxxxx</code> (where <code>x</code> means "may be * <code>0</code> or <code>1</code>"), then the group consists of * just that byte. The byte is zero-extended to form a character. * * <p> If the first byte of a group matches the bit pattern * <code>110xxxxx</code>, then the group consists of that byte * <code>a</code> and a second byte <code>b</code>. If there is no * byte <code>b</code> (because byte <code>a</code> was the last * of the bytes to be read), or if byte <code>b</code> does not * match the bit pattern <code>10xxxxxx</code>, then a * <code>UTFDataFormatException</code> is thrown. Otherwise, the * group is converted to the character: * * <p> <pre><code> * (char)(((a& 0x1F) << 6) | (b & 0x3F)) * </code></pre> * * If the first byte of a group matches the bit pattern * <code>1110xxxx</code>, then the group consists of that byte * <code>a</code> and two more bytes <code>b</code> and * <code>c</code>. If there is no byte <code>c</code> (because * byte <code>a</code> was one of the last two of the bytes to be * read), or either byte <code>b</code> or byte <code>c</code> * does not match the bit pattern <code>10xxxxxx</code>, then a * <code>UTFDataFormatException</code> is thrown. Otherwise, the * group is converted to the character: * * <p> <pre><code> * (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F)) * </code></pre> * * If the first byte of a group matches the pattern * <code>1111xxxx</code> or the pattern <code>10xxxxxx</code>, * then a <code>UTFDataFormatException</code> is thrown. * * <p> If end of file is encountered at any time during this * entire process, then an <code>EOFException</code> is thrown. * * <p> After every group has been converted to a character by this * process, the characters are gathered, in the same order in * which their corresponding groups were read from the input * stream, to form a <code>String</code>, which is returned. * * <p> The current byte order setting is ignored. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * <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. * * @return a String read from the stream. * * @exception EOFException if this stream reaches the end * before reading all the bytes. * @exception UTFDataFormatException if the bytes do not represent a * valid modified UTF-8 encoding of a string. * @exception IOException if an I/O error occurs. */ String readUTF() throws IOException; /** * Reads <code>len</code> bytes from the stream, and stores themLines 1–500 of 1000. Load more
/* * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.imageio.stream; import java.io.Closeable; import java.io.DataInput; import java.io.IOException; import java.nio.ByteOrder; /** * A seekable input stream interface for use by * <code>ImageReader</code>s. Various input sources, such as * <code>InputStream</code>s and <code>File</code>s, * as well as future fast I/O sources may be "wrapped" by a suitable * implementation of this interface for use by the Image I/O API. * * @see ImageInputStreamImpl * @see FileImageInputStream * @see FileCacheImageInputStream * @see MemoryCacheImageInputStream * */ public interface ImageInputStream extends DataInput, Closeable { /** * Sets the desired byte order for future reads of data values * from this stream. For example, the sequence of bytes '0x01 * 0x02 0x03 0x04' if read as a 4-byte integer would have the * value '0x01020304' using network byte order and the value * '0x04030201' under the reverse byte order. * * <p> The enumeration class <code>java.nio.ByteOrder</code> is * used to specify the byte order. A value of * <code>ByteOrder.BIG_ENDIAN</code> specifies so-called * big-endian or network byte order, in which the high-order byte * comes first. Motorola and Sparc processors store data in this * format, while Intel processors store data in the reverse * <code>ByteOrder.LITTLE_ENDIAN</code> order. * * <p> The byte order has no effect on the results returned from * the <code>readBits</code> method (or the value written by * <code>ImageOutputStream.writeBits</code>). * * @param byteOrder one of <code>ByteOrder.BIG_ENDIAN</code> or * <code>java.nio.ByteOrder.LITTLE_ENDIAN</code>, indicating whether * network byte order or its reverse will be used for future * reads. * * @see java.nio.ByteOrder * @see #getByteOrder * @see #readBits(int) */ void setByteOrder(ByteOrder byteOrder); /** * Returns the byte order with which data values will be read from * this stream as an instance of the * <code>java.nio.ByteOrder</code> enumeration. * * @return one of <code>ByteOrder.BIG_ENDIAN</code> or * <code>ByteOrder.LITTLE_ENDIAN</code>, indicating which byte * order is being used. * * @see java.nio.ByteOrder * @see #setByteOrder */ ByteOrder getByteOrder(); /** * Reads a single byte from the stream and returns it as an * integer between 0 and 255. If the end of the stream is * reached, -1 is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a byte value from the stream, as an int, or -1 to * indicate EOF. * * @exception IOException if an I/O error occurs. */ int read() throws IOException; /** * Reads up to <code>b.length</code> bytes from the stream, and * stores them into <code>b</code> starting at index 0. The * number of bytes read is returned. If no bytes can be read * because the end of the stream has been reached, -1 is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param b an array of bytes to be written to. * * @return the number of bytes actually read, or <code>-1</code> * to indicate EOF. * * @exception NullPointerException if <code>b</code> is * <code>null</code>. * * @exception IOException if an I/O error occurs. */ int read(byte[] b) throws IOException; /** * Reads up to <code>len</code> bytes from the stream, and stores * them into <code>b</code> starting at index <code>off</code>. * The number of bytes read is returned. If no bytes can be read * because the end of the stream has been reached, <code>-1</code> * is returned. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param b an array of bytes to be written to. * @param off the starting position within <code>b</code> to write to. * @param len the maximum number of <code>byte</code>s to read. * * @return the number of bytes actually read, or <code>-1</code> * to indicate EOF. * * @exception NullPointerException if <code>b</code> is * <code>null</code>. * @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 IOException if an I/O error occurs. */ int read(byte[] b, int off, int len) throws IOException; /** * Reads up to <code>len</code> bytes from the stream, and * modifies the supplied <code>IIOByteBuffer</code> to indicate * the byte array, offset, and length where the data may be found. * The caller should not attempt to modify the data found in the * <code>IIOByteBuffer</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @param buf an IIOByteBuffer object to be modified. * @param len the maximum number of <code>byte</code>s to read. * * @exception IndexOutOfBoundsException if <code>len</code> is * negative. * @exception NullPointerException if <code>buf</code> is * <code>null</code>. * * @exception IOException if an I/O error occurs. */ void readBytes(IIOByteBuffer buf, int len) throws IOException; /** * Reads a byte from the stream and returns a <code>boolean</code> * value of <code>true</code> if it is nonzero, <code>false</code> * if it is zero. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a boolean value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ boolean readBoolean() throws IOException; /** * Reads a byte from the stream and returns it as a * <code>byte</code> value. Byte values between <code>0x00</code> * and <code>0x7f</code> represent integer values between * <code>0</code> and <code>127</code>. Values between * <code>0x80</code> and <code>0xff</code> represent negative * values from <code>-128</code> to <code>/1</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed byte value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ byte readByte() throws IOException; /** * Reads a byte from the stream, and (conceptually) converts it to * an int, masks it with <code>0xff</code> in order to strip off * any sign-extension bits, and returns it as a <code>byte</code> * value. * * <p> Thus, byte values between <code>0x00</code> and * <code>0x7f</code> are simply returned as integer values between * <code>0</code> and <code>127</code>. Values between * <code>0x80</code> and <code>0xff</code>, which normally * represent negative <code>byte</code>values, will be mapped into * positive integers between <code>128</code> and * <code>255</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned byte value from the stream. * * @exception EOFException if the end of the stream is reached. * @exception IOException if an I/O error occurs. */ int readUnsignedByte() throws IOException; /** * Reads two bytes from the stream, and (conceptually) * concatenates them according to the current byte order, and * returns the result as a <code>short</code> value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed short value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ short readShort() throws IOException; /** * Reads two bytes from the stream, and (conceptually) * concatenates them according to the current byte order, converts * the resulting value to an <code>int</code>, masks it with * <code>0xffff</code> in order to strip off any sign-extension * buts, and returns the result as an unsigned <code>int</code> * value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned short value from the stream, as an int. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ int readUnsignedShort() throws IOException; /** * Equivalent to <code>readUnsignedShort</code>, except that the * result is returned using the <code>char</code> datatype. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned char value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #readUnsignedShort */ char readChar() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as an <code>int</code>. * * <p> The bit offset within the stream is ignored and treated as * though it were zero. * * @return a signed int value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ int readInt() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order, converts the result * to a long, masks it with <code>0xffffffffL</code> in order to * strip off any sign-extension bits, and returns the result as an * unsigned <code>long</code> value. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return an unsigned int value from the stream, as a long. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ long readUnsignedInt() throws IOException; /** * Reads 8 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>long</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a signed long value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ long readLong() throws IOException; /** * Reads 4 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>float</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a float value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ float readFloat() throws IOException; /** * Reads 8 bytes from the stream, and (conceptually) concatenates * them according to the current byte order and returns the result * as a <code>double</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a double value from the stream. * * @exception EOFException if the stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * * @see #getByteOrder */ double readDouble() throws IOException; /** * Reads the next line of text from the input stream. It reads * successive bytes, converting each byte separately into a * character, until it encounters a line terminator or end of * file; the characters read are then returned as a * <code>String</code>. Note that because this method processes * bytes, it does not support input of the full Unicode character * set. * * <p> If end of file is encountered before even one byte can be * read, then <code>null</code> is returned. Otherwise, each byte * that is read is converted to type <code>char</code> by * zero-extension. If the character <code>'\n'</code> is * encountered, it is discarded and reading ceases. If the * character <code>'\r'</code> is encountered, it is discarded * and, if the following byte converts  to the character * <code>'\n'</code>, then that is discarded also; reading then * ceases. If end of file is encountered before either of the * characters <code>'\n'</code> and <code>'\r'</code> is * encountered, reading ceases. Once reading has ceased, a * <code>String</code> is returned that contains all the * characters read and not discarded, taken in order. Note that * every character in this string will have a value less than * <code>\u0100</code>, that is, <code>(char)256</code>. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * @return a String containing a line of text from the stream. * * @exception IOException if an I/O error occurs. */ String readLine() throws IOException; /** * Reads in a string that has been encoded using a * <a href="../../../java/io/DataInput.html#modified-utf-8">modified * UTF-8</a> * format. The general contract of <code>readUTF</code> is that * it reads a representation of a Unicode character string encoded * in modified UTF-8 format; this string of characters is * then returned as a <code>String</code>. * * <p> First, two bytes are read and used to construct an unsigned * 16-bit integer in the manner of the * <code>readUnsignedShort</code> method, using network byte order * (regardless of the current byte order setting). This integer * value is called the <i>UTF length</i> and specifies the number * of additional bytes to be read. These bytes are then converted * to characters by considering them in groups. The length of each * group is computed from the value of the first byte of the * group. The byte following a group, if any, is the first byte of * the next group. * * <p> If the first byte of a group matches the bit pattern * <code>0xxxxxxx</code> (where <code>x</code> means "may be * <code>0</code> or <code>1</code>"), then the group consists of * just that byte. The byte is zero-extended to form a character. * * <p> If the first byte of a group matches the bit pattern * <code>110xxxxx</code>, then the group consists of that byte * <code>a</code> and a second byte <code>b</code>. If there is no * byte <code>b</code> (because byte <code>a</code> was the last * of the bytes to be read), or if byte <code>b</code> does not * match the bit pattern <code>10xxxxxx</code>, then a * <code>UTFDataFormatException</code> is thrown. Otherwise, the * group is converted to the character: * * <p> <pre><code> * (char)(((a& 0x1F) << 6) | (b & 0x3F)) * </code></pre> * * If the first byte of a group matches the bit pattern * <code>1110xxxx</code>, then the group consists of that byte * <code>a</code> and two more bytes <code>b</code> and * <code>c</code>. If there is no byte <code>c</code> (because * byte <code>a</code> was one of the last two of the bytes to be * read), or either byte <code>b</code> or byte <code>c</code> * does not match the bit pattern <code>10xxxxxx</code>, then a * <code>UTFDataFormatException</code> is thrown. Otherwise, the * group is converted to the character: * * <p> <pre><code> * (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F)) * </code></pre> * * If the first byte of a group matches the pattern * <code>1111xxxx</code> or the pattern <code>10xxxxxx</code>, * then a <code>UTFDataFormatException</code> is thrown. * * <p> If end of file is encountered at any time during this * entire process, then an <code>EOFException</code> is thrown. * * <p> After every group has been converted to a character by this * process, the characters are gathered, in the same order in * which their corresponding groups were read from the input * stream, to form a <code>String</code>, which is returned. * * <p> The current byte order setting is ignored. * * <p> The bit offset within the stream is reset to zero before * the read occurs. * * <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. * * @return a String read from the stream. * * @exception EOFException if this stream reaches the end * before reading all the bytes. * @exception UTFDataFormatException if the bytes do not represent a * valid modified UTF-8 encoding of a string. * @exception IOException if an I/O error occurs. */ String readUTF() throws IOException; /** * Reads <code>len</code> bytes from the stream, and stores them