| Methods Summary |
|---|
| public void | close()This method closes this StringReader. Once it is closed, you can no
longer read from it. Only the first invocation of this method has any
effect.
synchronized (lock) {
if (isOpen()) {
str = null;
}
}
|
| private boolean | isOpen()Answer a boolean indicating whether or not this StringReader is open.
return str != null;
|
| public void | mark(int readLimit)Set a Mark position in this Reader. The parameter readLimit
is ignored for StringReaders. Sending reset() will reposition the reader
back to the marked position provided the mark has not been invalidated.
if (readLimit >= 0) {
synchronized (lock) {
if (isOpen()) {
markpos = pos;
} else {
throw new IOException("StringReader is closed");
}
}
} else {
throw new IllegalArgumentException();
}
|
| public boolean | markSupported()Answers a boolean indicating whether or not this StringReader supports
mark() and reset(). This method always returns true.
return true;
|
| public int | read()Reads a single character from this StringReader and returns the result as
an int. The 2 higher-order bytes are set to 0. If the end of reader was
encountered then return -1.
synchronized (lock) {
if (isOpen()) {
if (pos != count) {
return str.charAt(pos++);
}
return -1;
}
throw new IOException("StringReader is closed");
}
|
| public int | read(char[] buf, int offset, int count)Reads at most count characters from this StringReader and
stores them at offset in the character array
buf. Returns the number of characters actually read or -1
if the end of reader was encountered.
// avoid int overflow
if (0 <= offset && offset <= buf.length && 0 <= count
&& count <= buf.length - offset) {
synchronized (lock) {
if (isOpen()) {
if (pos == this.count) {
return -1;
}
int end = pos + count > this.count ? this.count : pos
+ count;
str.getChars(pos, end, buf, offset);
int read = end - pos;
pos = end;
return read;
}
throw new IOException("StringReader is closed");
}
}
throw new ArrayIndexOutOfBoundsException();
|
| public boolean | ready()Answers a boolean indicating whether or not this
StringReader is ready to be read without blocking. If the result is
true, the next read() will not block. If
the result is false this Reader may or may not block when
read() is sent. The implementation in StringReader always
returns true even when it has been closed.
synchronized (lock) {
if (isOpen()) {
return true;
}
throw new IOException("StringReader is closed");
}
|
| public void | reset()Reset this StringReader's position to the last mark()
location. Invocations of read()/skip() will occur from
this new location. If this Reader was not marked, the StringReader is
reset to the beginning of the String.
synchronized (lock) {
if (isOpen()) {
pos = markpos != -1 ? markpos : 0;
} else {
throw new IOException("StringReader is closed");
}
}
|
| public long | skip(long count)Skips count number of characters in this StringReader.
Subsequent read()'s will not return these characters
unless reset() is used.
synchronized (lock) {
if (isOpen()) {
if (count <= 0) {
return 0;
}
long skipped = 0;
if (count < this.count - pos) {
pos = pos + (int) count;
skipped = count;
} else {
skipped = this.count - pos;
pos = this.count;
}
return skipped;
}
throw new IOException("StringReader is closed");
}
|
