DataInputStream
* to read from the specified subordinate stream.
*
* @param in The subordinate InputStream to read from
*/
public LittleEndianInputStream(InputStream in)
{
super(in);
}
/**
* This method reads bytes from the underlying stream into the specified
* byte array buffer. It will attempt to fill the buffer completely, but
* may return a short count if there is insufficient data remaining to be
* read to fill the buffer.
*
* @param b The buffer into which bytes will be read.
*
* @return The actual number of bytes read, or -1 if end of stream reached
* before reading any bytes.
*
* @exception IOException If an error occurs.
*/
public int read(byte[] b)
throws IOException
{
return in.read(b, 0, b.length);
}
/**
* This method reads bytes from the underlying stream into the specified
* byte array buffer. It will attempt to read len bytes and
* will start storing them at position off into the buffer.
* This method can return a short count if there is insufficient data
* remaining to be read to complete the desired read length.
*
* @param b The buffer into which bytes will be read.
* @param off The offset into the buffer to start storing bytes.
* @param len The requested number of bytes to read.
*
* @return The actual number of bytes read, or -1 if end of stream reached
* before reading any bytes.
*
* @exception IOException If an error occurs.
*/
public int read(byte[] b, int off, int len)
throws IOException
{
return in.read(b, off, len);
}
/**
* This method reads a Java boolean value from an input stream. It does
* so by reading a single byte of data. If that byte is zero, then the
* value returned is 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
*/
public boolean readBoolean()
throws IOException
{
return convertToBoolean(in.read());
}
/**
* 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
*/
public byte readByte()
throws IOException
{
return convertToByte(in.read());
}
/**
* 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 & 0xFF) << 8) | (byte2 & 0xFF)
*
* 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
*/
public char readChar()
throws IOException
{
readFully(buf, 0, 2);
return convertToChar(buf);
}
/**
* 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
*/
public double readDouble()
throws IOException
{
return Double.longBitsToDouble(readLong());
}
/**
* 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
*/
public float readFloat()
throws IOException
{
return Float.intBitsToFloat(readInt());
}
/**
* 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 b 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
*/
public void readFully(byte[] b)
throws IOException
{
readFully(b, 0, b.length);
}
/**
* 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
*/
public void readFully(byte[] buf, int offset, int len)
throws IOException
{
if (len < 0)
throw new IndexOutOfBoundsException("Negative length: " + len);
while (len > 0)
{
// in.read will block until some data is available.
int numread = in.read(buf, offset, len);
if (numread < 0)
throw new EOFException();
len -= numread;
offset += numread;
}
}
/**
* 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
*/
public int readInt()
throws IOException
{
readFully(buf, 0, 4);
return convertToInt(buf);
}
/**
* 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.
*
* This method can read data that was written by an object implementing the
* writeLine() method in DataOutput.
*
* @return The line read as a String
*
* @exception IOException If an error occurs
*
* @see DataOutput
*
* @deprecated
*/
public String readLine()
throws IOException
{
CPStringBuilder strb = new CPStringBuilder();
while (true)
{
int c = in.read();
if (c == -1) // got an EOF
return strb.length() > 0 ? strb.toString() : null;
if (c == '\r')
{
int next_c = in.read();
if (next_c != '\n' && next_c != -1)
{
if (!(in instanceof PushbackInputStream))
in = new PushbackInputStream(in);
((PushbackInputStream) in).unread(next_c);
}
break;
}
if (c == '\n')
break;
strb.append((char) c);
}
return strb.length() > 0 ? strb.toString() : "";
}
/**
* 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
*/
public long readLong()
throws IOException
{
readFully(buf, 0, 8);
return convertToLong(buf);
}
/**
* 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
*/
public short readShort()
throws IOException
{
readFully(buf, 0, 2);
return convertToShort(buf);
}
/**
* 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 writeUnsignedByte() 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
*/
public int readUnsignedByte()
throws IOException
{
return convertToUnsignedByte(in.read());
}
/**
* 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 writeUnsignedShort() 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
*/
public int readUnsignedShort()
throws IOException
{
readFully(buf, 0, 2);
return convertToUnsignedShort(buf);
}
/**
* This method attempts to skip and discard the specified number of bytes
* in the input stream. It may actually skip fewer bytes than requested.
* This method will not skip any bytes if passed a negative number of bytes
* to skip.
*
* @param n The requested number of bytes to skip.
*
* @return The requested number of bytes to skip.
*
* @exception IOException If an error occurs.
* @specnote The JDK docs claim that this returns the number of bytes
* actually skipped. The JCL claims that this method can throw an
* EOFException. Neither of these appear to be true in the JDK 1.3's
* implementation. This tries to implement the actual JDK behaviour.
*/
public int skipBytes(int n)
throws IOException
{
if (n <= 0)
return 0;
try
{
return (int) in.skip(n);
}
catch (EOFException x)
{
// do nothing.
}
return n;
}
protected boolean convertToBoolean(int b)
throws EOFException
{
if (b < 0)
throw new EOFException();
return (b != 0);
}
protected byte convertToByte(int i)
throws EOFException
{
if (i < 0)
throw new EOFException();
return (byte) i;
}
protected int convertToUnsignedByte(int i)
throws EOFException
{
if (i < 0)
throw new EOFException();
return (i & 0xFF);
}
/**
* Less significant byte first.
*/
protected char convertToChar(byte[] buf)
{
return (char) ((buf [ 1 ] << 8) | (buf [ 0 ] & 0xff));
}
/**
* Less significant byte first.
*/
protected short convertToShort(byte[] buf)
{
return (short) ((buf [ 1 ] << 8) | (buf [ 0 ] & 0xff));
}
/**
* Less significant byte first.
*/
protected int convertToUnsignedShort(byte[] buf)
{
return (((buf [ 1 ] & 0xff) << 8) | (buf [ 0 ] & 0xff));
}
/**
* Less significant byte first.
*/
protected int convertToInt(byte[] buf)
{
return (((buf [ 3 ] & 0xff) << 24) | ((buf [ 2 ] & 0xff) << 16) |
((buf [ 1 ] & 0xff) << 8) | (buf [ 0 ] & 0xff));
}
/**
* Less significant byte first.
*/
protected long convertToLong(byte[] buf)
{
return (((long) (buf [ 7 ] & 0xff) << 56) |
((long) (buf [ 6 ] & 0xff) << 48) |
((long) (buf [ 5 ] & 0xff) << 40) |
((long) (buf [ 4 ] & 0xff) << 32) |
((long) (buf [ 3 ] & 0xff) << 24) |
((long) (buf [ 2 ] & 0xff) << 16) |
((long) (buf [ 1 ] & 0xff) << 8) | ((long) (buf [ 0 ] & 0xff)));
}
/**
* This should never be called.
*
* @throws InternalError, always.
*/
public String readUTF()
{
throw new InternalError();
}
}