| Methods Summary |
|---|
| public abstract void | close()Closes this reader. Implementations of this method should free any
resources associated with the reader.
|
| public void | mark(int readLimit)Sets a mark position in this reader. The parameter {@code readLimit}
indicates how many characters can be read before the mark is invalidated.
Calling {@code reset()} will reposition the reader back to the marked
position if {@code readLimit} has not been surpassed.
This default implementation simply throws an {@code IOException};
subclasses must provide their own implementation.
throw new IOException();
|
| public boolean | markSupported()Indicates whether this reader supports the {@code mark()} and
{@code reset()} methods. This default implementation returns
{@code false}.
return false;
|
| public int | read(java.nio.CharBuffer target)Reads characters and puts them into the {@code target} character buffer.
if (null == target) {
throw new NullPointerException();
}
int length = target.length();
char[] buf = new char[length];
length = Math.min(length, read(buf));
if (length > 0) {
target.put(buf, 0, length);
}
return length;
|
| public int | read()Reads a single character from this reader and returns it as an integer
with the two higher-order bytes set to 0. Returns -1 if the end of the
reader has been reached.
synchronized (lock) {
char charArray[] = new char[1];
if (read(charArray, 0, 1) != -1) {
return charArray[0];
}
return -1;
}
|
| public int | read(char[] buf)Reads characters from this reader and stores them in the character array
{@code buf} starting at offset 0. Returns the number of characters
actually read or -1 if the end of the reader has been reached.
// BEGIN android-note
// changed array notation to be consistent with the rest of harmony
// END android-note
return read(buf, 0, buf.length);
|
| public abstract int | read(char[] buf, int offset, int count)Reads at most {@code count} characters from this reader and stores them
at {@code offset} in the character array {@code buf}. Returns the number
of characters actually read or -1 if the end of the reader has been
reached.
|
| public boolean | ready()Indicates whether this reader is ready to be read without blocking.
Returns {@code true} if this reader will not block when {@code read} is
called, {@code false} if unknown or blocking will occur. This default
implementation always returns {@code false}.
return false;
|
| public void | reset()Resets this reader's position to the last {@code mark()} location.
Invocations of {@code read()} and {@code skip()} will occur from this new
location. If this reader has not been marked, the behavior of
{@code reset()} is implementation specific. This default
implementation throws an {@code IOException}.
throw new IOException();
|
| public long | skip(long count)Skips {@code amount} characters in this reader. Subsequent calls of
{@code read} methods will not return these characters unless {@code
reset()} is used. This method may perform multiple reads to read {@code
count} characters.
if (count < 0) {
throw new IllegalArgumentException();
}
synchronized (lock) {
long skipped = 0;
int toRead = count < 512 ? (int) count : 512;
char charsSkipped[] = new char[toRead];
while (skipped < count) {
int read = read(charsSkipped, 0, toRead);
if (read == -1) {
return skipped;
}
skipped += read;
if (read < toRead) {
return skipped;
}
if (count - skipped < toRead) {
toRead = (int) (count - skipped);
}
}
return skipped;
}
|
