DataInput interface.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Tom Tromey value is true, a byte with the value of
* 1 will be written, otherwise a byte with the value of 0 will be
* written.
*
* The value written can be read using the readBoolean
* method in DataInput.
*
* @param value The boolean value to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readBoolean
*/
void writeBoolean(boolean value) throws IOException;
/**
* This method writes a Java byte value to an output stream. The
* byte to be written will be in the lowest 8 bits of the
* int value passed.
*
* The value written can be read using the readByte or
* readUnsignedByte methods in DataInput.
*
* @param value The int value to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readByte
* @see DataInput#readUnsignedByte
*/
void writeByte(int value) throws IOException;
/**
* This method writes a Java char value to an output stream. The
* char to be written will be in the lowest 16 bits of the int
* value passed. These bytes will be written "big endian". That is,
* with the high byte written first in the following manner:
*
* byte0 = (byte)((value & 0xFF00) >> 8);
*
* byte1 = (byte)(value & 0x00FF);
*
* The value written can be read using the readChar
* method in DataInput.
*
* @param value The char value to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readChar
*/
void writeChar(int value) throws IOException;
/**
* This method writes a Java short value to an output stream. The
* char to be written will be in the lowest 16 bits of the int
* value passed. These bytes will be written "big endian". That is,
* with the high byte written first in the following manner:
*
* byte0 = (byte)((value & 0xFF00) >> 8);
*
* byte1 = (byte)(value & 0x00FF);
*
* The value written can be read using the readShort and
* readUnsignedShort methods in DataInput.
*
* @param value The int value to write as a 16-bit value
*
* @exception IOException If an error occurs
*
* @see DataInput#readShort
* @see DataInput#readUnsignedShort
*/
void writeShort(int value) throws IOException;
/**
* This method writes a Java int value to an output stream. The 4 bytes
* of the passed value will be written "big endian". That is, with
* the high byte written first in the following manner:
*
* byte0 = (byte)((value & 0xFF000000) >> 24);
*
* byte1 = (byte)((value & 0x00FF0000) >> 16);
* byte2 = (byte)((value & 0x0000FF00) >> 8);
* byte3 = (byte)(value & 0x000000FF);
*
* The value written can be read using the readInt
* method in DataInput.
*
* @param value The int value to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readInt
*/
void writeInt(int value) throws IOException;
/**
* This method writes a Java long value to an output stream. The 8 bytes
* of the passed value will be written "big endian". That is, with
* the high byte written first in the following manner:
*
* byte0 = (byte)((value & 0xFF00000000000000L) >> 56);
*
* byte1 = (byte)((value & 0x00FF000000000000L) >> 48);
* byte2 = (byte)((value & 0x0000FF0000000000L) >> 40);
* byte3 = (byte)((value & 0x000000FF00000000L) >> 32);
* byte4 = (byte)((value & 0x00000000FF000000L) >> 24);
* byte5 = (byte)((value & 0x0000000000FF0000L) >> 16);
* byte6 = (byte)((value & 0x000000000000FF00L) >> 8);
* byte7 = (byte)(value & 0x00000000000000FFL);
*
* The value written can be read using the readLong
* method in DataInput.
*
* @param value The long value to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readLong
*/
void writeLong(long value) throws IOException;
/**
* This method writes a Java float value to the stream. This
* value is written by first calling the method
* Float.floatToIntBits
* to retrieve an int representing the floating point number,
* then writing this int value to the stream exactly the same
* as the writeInt() method does.
*
* The value written can be read using the readFloat
* method in DataInput.
*
* @param value The float value to write
*
* @exception IOException If an error occurs
*
* @see writeInt
* @see DataInput#readFloat
* @see Float#floatToIntBits
*/
void writeFloat(float value) throws IOException;
/**
* This method writes a Java double value to the stream. This
* value is written by first calling the method
* Double.doubleToLongBits
* to retrieve an long representing the floating point number,
* then writing this long value to the stream exactly the same
* as the writeLong() method does.
*
* The value written can be read using the readDouble
* method in DataInput.
*
* @param value The double value to write
*
* @exception IOException If any other error occurs
*
* @see writeLong
* @see DataInput#readDouble
* @see Double#doubleToLongBits
*/
void writeDouble(double value) throws IOException;
/**
* This method writes all the bytes in a String out to the
* stream. One byte is written for each character in the
* String.
* The high eight bits of each character are discarded, thus this
* method is inappropriate for completely representing Unicode characters.
*
* @param value The String to write
*
* @exception IOException If an error occurs
*/
void writeBytes(String value) throws IOException;
/**
* This method writes all the characters of a String to an
* output stream as an array of char's. Each character
* is written using the method specified in the writeChar
* method.
*
* @param value The String to write
*
* @exception IOException If an error occurs
*
* @see writeChar
*/
void writeChars(String value) throws IOException;
/**
* This method writes a Java String to the stream in a modified
* UTF-8 format. First, two bytes are written to the stream indicating the
* number of bytes to follow. This is written in the form of a Java
* short value in the same manner used by the
* writeShort method. Note that this is the number of
* bytes in the
* encoded String not the String length. Next
* come the encoded characters. Each character in the String
* is encoded as either one, two or three bytes. For characters in the
* range of \u0001 to \u007F, one byte is used.
* The character
* value goes into bits 0-7 and bit eight is 0. For characters in the range
* of \u0080 to \u007FF, two bytes are used. Bits
* 6-10 of the character value are encoded bits 0-4 of the first byte, with
* the high bytes having a value of "110". Bits 0-5 of the character value
* are stored in bits 0-5 of the second byte, with the high bits set to
* "10". This type of encoding is also done for the null character
* \u0000. This eliminates any C style NUL character values
* in the output. All remaining characters are stored as three bytes.
* Bits 12-15 of the character value are stored in bits 0-3 of the first
* byte. The high bits of the first bytes are set to "1110". Bits 6-11
* of the character value are stored in bits 0-5 of the second byte. The
* high bits of the second byte are set to "10". And bits 0-5 of the
* character value are stored in bits 0-5 of byte three, with the high bits
* of that byte set to "10".
*
* The value written can be read using the readUTF
* method in DataInput.
*
* @param value The String to write
*
* @exception IOException If an error occurs
*
* @see DataInput#readUTF
*/
void writeUTF(String value) throws IOException;
/**
* This method writes an 8-bit value (passed into the method as a Java
* int) to an output stream. The low 8 bits of the
* passed value are written.
*
* @param value The byte to write to the output stream
*
* @exception IOException If an error occurs
*/
void write(int value) throws IOException;
/**
* This method writes the raw byte array passed in to the output stream.
*
* @param buf The byte array to write
*
* @exception IOException If an error occurs
*/
void write(byte[] buf) throws IOException;
/**
* This method writes raw bytes from the passed array buf
* starting
* offset bytes into the buffer. The number of bytes
* written will be exactly len.
*
* @param buf The buffer from which to write the data
* @param offset The offset into the buffer to start writing data from
* @param len The number of bytes to write from the buffer to the output
* stream
*
* @exception IOException If any other error occurs
*/
void write(byte[] buf, int offset, int len) throws IOException;
} // interface DataOutput