| Methods Summary |
|---|
| java.lang.String | decodeUTF(int utfSize)
// BEGIN android-removed
// byte[] buf;
// char[] out = null;
// boolean makeBuf = true;
//
// /*
// * Try to avoid the synchronization -- if we get a stale value for
// * useShared then there is no foul below, but those that sync on the
// * lock must see the right value.
// */
// if (utfSize <= MAX_BUF_SIZE && useShared) {
// synchronized (cacheLock) {
// if (useShared) {
// useShared = false;
// makeBuf = false;
// }
// }
// }
// if (makeBuf) {
// buf = new byte[utfSize];
// out = new char[utfSize];
// } else {
// /*
// * Need to 'sample' byteBuf and charBuf before using them because
// * they are not protected by the cacheLock. They may get out of sync
// * with the static and one another, but that is ok because we
// * explicitly check and fix their length after sampling.
// */
// buf = byteBuf;
// if (buf.length < utfSize) {
// buf = byteBuf = new byte[utfSize];
// }
// out = charBuf;
// if (out.length < utfSize) {
// out = charBuf = new char[utfSize];
// }
// }
// END android-removed
// BEGIN android-added
byte[] buf = new byte[utfSize];
char[] out = new char[utfSize];
// END android-added
readFully(buf, 0, utfSize);
String result;
result = Util.convertUTF8WithBuf(buf, out, 0, utfSize);
// BEGIN android-removed
// if (!makeBuf) {
// /*
// * Do not synchronize useShared on cacheLock, it will make it back
// * to main storage at some point, and no harm until it does.
// */
// useShared = true;
// }
//END android-removed
return result;
|
| public final int | read(byte[] buffer)Reads bytes from this stream into the byte array {@code buffer}. Returns
the number of bytes that have been read.
return in.read(buffer, 0, buffer.length);
|
| public final int | read(byte[] buffer, int offset, int length)Reads at most {@code length} bytes from this stream and stores them in
the byte array {@code buffer} starting at {@code offset}. Returns the
number of bytes that have been read or -1 if no bytes have been read and
the end of the stream has been reached.
return in.read(buffer, offset, length);
|
| public final boolean | readBoolean()Reads a boolean from this stream.
int temp = in.read();
if (temp < 0) {
throw new EOFException();
}
return temp != 0;
|
| public final byte | readByte()Reads an 8-bit byte value from this stream.
int temp = in.read();
if (temp < 0) {
throw new EOFException();
}
return (byte) temp;
|
| public final char | readChar()Reads a 16-bit character value from this stream.
int b1 = in.read();
int b2 = in.read();
if ((b1 | b2) < 0) {
throw new EOFException();
}
return (char) ((b1 << 8) + b2);
|
| public final double | readDouble()Reads a 64-bit double value from this stream.
return Double.longBitsToDouble(readLong());
|
| public final float | readFloat()Reads a 32-bit float value from this stream.
return Float.intBitsToFloat(readInt());
|
| public final void | readFully(byte[] buffer, int offset, int length)Reads bytes from this stream and stores them in the byte array {@code
buffer} starting at the position {@code offset}. This method blocks until
{@code length} bytes have been read. If {@code length} is zero, then this
method returns without reading any bytes.
// BEGIN android-removed
// if (length < 0) {
// throw new IndexOutOfBoundsException();
// }
// END android-removed
if (length == 0) {
return;
}
if (in == null) {
throw new NullPointerException(Msg.getString("KA00b")); //$NON-NLS-1$
}
if (buffer == null) {
throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
}
// BEGIN android-changed
// Exception priorities (in case of multiple errors) differ from
// RI, but are spec-compliant.
// used (offset | length) < 0 instead of separate (offset < 0) and
// (length < 0) check to safe one operation
if ((offset | length) < 0 || offset > buffer.length - length) {
throw new IndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
}
// END android-changed
while (length > 0) {
int result = in.read(buffer, offset, length);
if (result < 0) {
throw new EOFException();
}
offset += result;
length -= result;
}
|
| public final void | readFully(byte[] buffer)Reads bytes from this stream into the byte array {@code buffer}. This
method will block until {@code buffer.length} number of bytes have been
read.
readFully(buffer, 0, buffer.length);
|
| public final int | readInt()Reads a 32-bit integer value from this stream.
// BEGIN android-changed
byte[] buf = new byte[4];
int nread = 0;
while (nread < 4) {
int nbytes = in.read(buf, nread, 4 - nread);
if (nbytes == -1) {
throw new EOFException();
}
nread += nbytes;
}
int b1 = buf[0] & 0xff;
int b2 = buf[1] & 0xff;
int b3 = buf[2] & 0xff;
int b4 = buf[3] & 0xff;
return ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
// END android-changed
|
| public final java.lang.String | readLine()Returns a string that contains the next line of text available from the
source stream. A line is represented by zero or more characters followed
by {@code '\n'}, {@code '\r'}, {@code "\r\n"} or the end of the stream.
The string does not include the newline sequence.
StringBuffer line = new StringBuffer(80); // Typical line length
boolean foundTerminator = false;
while (true) {
int nextByte = in.read();
switch (nextByte) {
case -1:
if (line.length() == 0 && !foundTerminator) {
return null;
}
return line.toString();
case (byte) '\r":
if (foundTerminator) {
((PushbackInputStream) in).unread(nextByte);
return line.toString();
}
foundTerminator = true;
/* Have to be able to peek ahead one byte */
if (!(in.getClass() == PushbackInputStream.class)) {
in = new PushbackInputStream(in);
}
break;
case (byte) '\n":
return line.toString();
default:
if (foundTerminator) {
((PushbackInputStream) in).unread(nextByte);
return line.toString();
}
line.append((char) nextByte);
}
}
|
| public final long | readLong()Reads a 64-bit long value from this stream.
int i1 = readInt();
int b1 = in.read();
int b2 = in.read();
int b3 = in.read();
int b4 = in.read();
if ((b1 | b2 | b3 | b4) < 0) {
throw new EOFException();
}
return (((long) i1) << 32) + ((long) b1 << 24) + (b2 << 16) + (b3 << 8)
+ b4;
|
| public final short | readShort()Reads a 16-bit short value from this stream.
// BEGIN android-changed
byte[] buf = new byte[2];
int nread = 0;
while (nread < 2) {
int nbytes = in.read(buf, nread, 2 - nread);
if (nbytes == -1) {
throw new EOFException();
}
nread += nbytes;
}
int b1 = buf[0] & 0xff;
int b2 = buf[1] & 0xff;
return (short) ((b1 << 8) + b2);
// END android-changed
|
| public final java.lang.String | readUTF()Reads an string encoded in {@link DataInput modified UTF-8} from this
stream.
int utfSize = readUnsignedShort();
return decodeUTF(utfSize);
|
| public static final java.lang.String | readUTF(java.io.DataInput in)Reads a string encoded in {@link DataInput modified UTF-8} from the
{@code DataInput} stream {@code in}.
return in.readUTF();
|
| public final int | readUnsignedByte()Reads an unsigned 8-bit byte value from this stream and returns it as an
int.
int temp = in.read();
if (temp < 0) {
throw new EOFException();
}
return temp;
|
| public final int | readUnsignedShort()Reads a 16-bit unsigned short value from this stream and returns it as an
int.
int b1 = in.read();
int b2 = in.read();
if ((b1 | b2) < 0) {
throw new EOFException();
}
return ((b1 << 8) + b2);
|
| public final int | skipBytes(int count)Skips {@code count} number of bytes in this stream. Subsequent {@code
read()}s will not return these bytes unless {@code reset()} is used.
This method will not throw an {@link EOFException} if the end of the
input is reached before {@code count} bytes where skipped.
int skipped = 0;
long skip;
while (skipped < count && (skip = in.skip(count - skipped)) != 0) {
skipped += skip;
}
// BEGIN android-removed
// if (skipped < 0) {
// throw new EOFException();
// }
// END android-removed
return skipped;
|
