false. If the byte is non-zero, then
* the value returned is true.
*
* This method can read a boolean written by an object
* implementing the writeBoolean() method in the
* DataOutput interface.
*
* @return The boolean value read
*
* @exception EOFException If end of file is reached before
* reading the boolean
* @exception IOException If any other error occurs
*
* @see DataOutput#writeBoolean
*/
boolean readBoolean() throws EOFException, IOException;
/**
* This method reads a Java byte value from an input stream. The value
* is in the range of -128 to 127.
*
* This method can read a byte written by an object
* implementing the
* writeByte() method in the DataOutput interface.
*
* @return The byte value read
*
* @exception EOFException If end of file is reached before reading the byte
* @exception IOException If any other error occurs
*
* @see DataOutput#writeByte
*/
byte readByte() throws EOFException, IOException;
/**
* This method reads 8 unsigned bits into a Java int value from
* the stream. The value returned is in the range of 0 to 255.
*
* This method can read an unsigned byte written by an object
* implementing the
* writeByte() method in the DataOutput
* interface.
*
* @return The unsigned bytes value read as a Java int.
*
* @exception EOFException If end of file is reached before reading the value
* @exception IOException If any other error occurs
*
* @see DataOutput#writeByte
*/
int readUnsignedByte() throws EOFException, IOException;
/**
* This method reads a Java char value from an input stream.
* It operates by reading two bytes from the stream and converting them to
* a single 16-bit Java char. The two bytes are stored most
* significant byte first (i.e., "big endian") regardless of the native
* host byte ordering.
*
* As an example, if byte1 and byte2 represent the
* first and second byte read from the stream respectively, they will be
* transformed to a char in the following manner:
*
* (char)((byte1 << 8) + byte2)
*
* This method can read a char written by an object implementing
* the
* writeChar() method in the DataOutput interface.
*
* @return The char value read
*
* @exception EOFException If end of file is reached before reading the char
* @exception IOException If any other error occurs
*
* @see DataOutput#writeChar
*/
char readChar() throws EOFException, IOException;
/**
* This method reads a signed 16-bit value into a Java in from the stream.
* It operates by reading two bytes from the stream and converting them to
* a single 16-bit Java short. The two bytes are stored most
* significant byte first (i.e., "big endian") regardless of the native
* host byte ordering.
*
* As an example, if byte1 and byte2 represent the
* first and second byte read from the stream respectively, they will be
* transformed to a short in the following manner:
*
* (short)(((byte1 & 0xFF) << 8) + (byte2 & 0xFF))
*
* The value returned is in the range of -32768 to 32767. *
* This method can read a short written by an object
* implementing
* the writeShort() method in the DataOutput
* interface.
*
* @return The short value read
*
* @exception EOFException If end of file is reached before reading the value
* @exception IOException If any other error occurs
*
* @see DataOutput#writeShort
*/
short readShort() throws EOFException, IOException;
/**
* This method reads 16 unsigned bits into a Java int value from the stream.
* It operates by reading two bytes from the stream and converting them to
* a single Java int. The two bytes are stored most
* significant byte first (i.e., "big endian") regardless of the native
* host byte ordering.
*
* As an example, if byte1 and byte2 represent the
* first and second byte read from the stream respectively, they will be
* transformed to an int in the following manner:
*
* (int)(((byte1 0xFF) << 8) + (byte2 & 0xFF))
*
* The value returned is in the range of 0 to 65535. *
* This method can read an unsigned short written by an object implementing
* the writeShort() method in the
* DataOutput
* interface.
*
* @return The unsigned short value read as a Java int.
*
* @exception EOFException If end of file is reached before reading
* the value
* @exception IOException If any other error occurs
*
* @see DataOutput#writeShort
*/
int readUnsignedShort() throws EOFException, IOException;
/**
* This method reads a Java int value from an input stream
* It operates by reading four bytes from the stream and converting them to
* a single Java int. The bytes are stored most
* significant byte first (i.e., "big endian") regardless of the native
* host byte ordering.
*
* As an example, if byte1 through byte4 represent
* the first four bytes read from the stream, they will be
* transformed to an int in the following manner:
*
* (int)(((byte1 & 0xFF) << 24) + ((byte2 & 0xFF) << 16) +
* ((byte3 & 0xFF)<< 8) + (byte4 & 0xFF)))
*
* The value returned is in the range of -2147483648 to 2147483647. *
* This method can read an int written by an object
* implementing the writeInt() method in the
* DataOutput interface.
*
* @return The int value read
*
* @exception EOFException If end of file is reached before reading the int
* @exception IOException If any other error occurs
*
* @see DataOutput#writeInt
*/
int readInt() throws EOFException, IOException;
/**
* This method reads a Java long value from an input stream
* It operates by reading eight bytes from the stream and converting them to
* a single Java long. The bytes are stored most
* significant byte first (i.e., "big endian") regardless of the native
* host byte ordering.
*
* As an example, if byte1 through byte8 represent
* the first eight bytes read from the stream, they will be
* transformed to an long in the following manner:
*
* (long)(((byte1 & 0xFF) << 56) + ((byte2 & 0xFF) << 48) +
* ((byte3 & 0xFF) << 40) + ((byte4 & 0xFF) << 32) +
* ((byte5 & 0xFF) << 24) + ((byte6 & 0xFF) << 16) +
* ((byte7 & 0xFF) << 8) + (byte8 & 0xFF)))
*
*
* The value returned is in the range of -9223372036854775808 to * 9223372036854775807. *
* This method can read an long written by an object
* implementing the writeLong() method in the
* DataOutput interface.
*
* @return The long value read
*
* @exception EOFException If end of file is reached before reading the long
* @exception IOException If any other error occurs
*
* @see DataOutput#writeLong
*/
long readLong() throws EOFException, IOException;
/**
* This method reads a Java float value from an input stream. It operates
* by first reading an int value from the stream by calling the
* readInt() method in this interface, then converts that
* int to a float using the
* intBitsToFloat method in the class
* java.lang.Float.
*
* This method can read a float written by an object
* implementing
* the writeFloat() method in the DataOutput
* interface.
*
* @return The float value read
*
* @exception EOFException If end of file is reached before reading the
* float
* @exception IOException If any other error occurs
*
* @see DataOutput#writeFloat
* @see java.lang.Float#intBitsToFloat
*/
float readFloat() throws EOFException, IOException;
/**
* This method reads a Java double value from an input stream. It operates
* by first reading a long value from the stream by calling the
* readLong() method in this interface, then converts that
* long to a double using the
* longBitsToDouble method in the class
* java.lang.Double.
*
* This method can read a double written by an object
* implementing the writeDouble() method in the
* DataOutput interface.
*
* @return The double value read
*
* @exception EOFException If end of file is reached before reading the
* double
* @exception IOException If any other error occurs
*
* @see DataOutput#writeDouble
* @see java.lang.Double#longBitsToDouble
*/
double readDouble() throws EOFException, IOException;
/**
* This method reads the next line of text data from an input stream.
* It operates by reading bytes and converting those bytes to
* char
* values by treating the byte read as the low eight bits of the
* char and using 0 as the high eight bits. Because of this,
* it does not support the full 16-bit Unicode character set.
*
* The reading of bytes ends when either the end of file or a line terminator
* is encountered. The bytes read are then returned as a
* String.
* A line terminator is a byte sequence consisting of either
* \r, \n or \r\n. These termination
* charaters are discarded and are not returned as part of the string.
* A line is also terminated by an end of file condition.
*
*
* @return The line read as a String
*
* @exception IOException If an error occurs
*/
String readLine() throws IOException;
/**
* This method reads a String from an input stream that is
* encoded in a modified UTF-8 format. This format has a leading two byte
* sequence that contains the remaining number of bytes to read.
* This two byte
* sequence is read using the readUnsignedShort() method of this
* interface.
*
* After the number of remaining bytes have been determined, these bytes
* are read an transformed into char values. These
* char values are encoded in the stream using either a one,
* two, or three byte format.
* The particular format in use can be determined by examining the first
* byte read.
*
* If the first byte has a high order bit of 0, then
* that character consists on only one byte. This character value consists
* of seven bits that are at positions 0 through 6 of the byte. As an
* example, if byte1 is the byte read from the stream, it would
* be converted to a char like so:
*
* (char)byte1
*
* If the first byte has 110 as its high order bits, then the * character consists of two bytes. The bits that make up the character * value are in positions 0 through 4 of the first byte and bit positions * 0 through 5 of the second byte. (The second byte should have * 10 as its high order bits). These values are in most significant * byte first (i.e., "big endian") order. *
* As an example, if byte1 and byte2 are the first
* two bytes read respectively, and the high order bits of them match the
* patterns which indicate a two byte character encoding, then they would be
* converted to a Java char like so:
*
* (char)(((byte1 & 0x1F) << 6) + (byte2 & 0x3F))
*
* If the first byte has a 1110 as its high order bits, then the * character consists of three bytes. The bits that make up the character * value are in positions 0 through 3 of the first byte and bit positions * 0 through 5 of the other two bytes. (The second and third bytes should * have 10 as their high order bits). These values are in most * significant byte first (i.e., "big endian") order. *
* As an example, if byte1, byte2, and
* byte3 are the three bytes read, and the high order bits of
* them match the patterns which indicate a three byte character encoding,
* then they would be converted to a Java char like so:
*
*
* (char)(((byte1 & 0x0F) << 12) + ((byte2 & 0x3F) + (byte3 & 0x3F))
*
*
* Note that all characters are encoded in the method that requires the
* fewest number of bytes with the exception of the character with the
* value of \<llll>u0000 which is encoded as two bytes.
* This is a modification of the UTF standard used to prevent C language
* style NUL values from appearing in the byte stream.
*
* This method can read data that was written by an object implementing the
* writeUTF() method in DataOutput.
*
* @return The String read
*
* @exception EOFException If end of file is reached before reading the
* String
* @exception UTFDataFormatException If the data is not in UTF-8 format
* @exception IOException If any other error occurs
*
* @see DataOutput#writeUTF
*/
String readUTF() throws EOFException, UTFDataFormatException, IOException;
/**
* This method reads raw bytes into the passed array until the array is
* full. Note that this method blocks until the data is available and
* throws an exception if there is not enough data left in the stream to
* fill the buffer. Note also that zero length buffers are permitted.
* In this case, the method will return immediately without reading any
* bytes from the stream.
*
* @param buf The buffer into which to read the data
*
* @exception EOFException If end of file is reached before filling the
* buffer
* @exception IOException If any other error occurs
*/
void readFully(byte[] buf) throws EOFException, IOException;
/**
* This method reads raw bytes into the passed array buf
* starting
* offset bytes into the buffer. The number of bytes read
* will be
* exactly len. Note that this method blocks until the data is
* available and throws an exception if there is not enough data left in
* the stream to read len bytes. Note also that zero length
* buffers are permitted. In this case, the method will return immediately
* without reading any bytes from the stream.
*
* @param buf The buffer into which to read the data
* @param offset The offset into the buffer to start storing data
* @param len The number of bytes to read into the buffer
*
* @exception EOFException If end of file is reached before filling the
* buffer
* @exception IOException If any other error occurs
*/
void readFully(byte[] buf, int offset, int len)
throws EOFException, IOException;
/**
* This method skips and discards the specified number of bytes in an
* input stream. Note that this method may skip less than the requested
* number of bytes. The actual number of bytes skipped is returned.
* No bytes are skipped if a negative number is passed to this method.
*
* @param numBytes The number of bytes to skip
*
* @return The number of bytes actually skipped, which will always be
* numBytes
*
* @exception EOFException If end of file is reached before all bytes can be
* skipped
* @exception IOException If any other error occurs
*/
int skipBytes(int numBytes) throws EOFException, IOException;
} // interface DataInput