/**
* Marks the read limit of the StringReader.
*
* @param limit the maximum limit of bytes that can be read before the mark position becomes
* invalid
*/
public synchronized void mark(final int limit) {
try {
in.mark(limit);
} catch (IOException ioe) {
throw new RuntimeException(ioe.getMessage());
}
}
/**
* @return the current number of bytes ready for reading
* @exception IOException if an error occurs
*/
public synchronized int available() throws IOException {
if (in == null) {
throw new IOException("Stream Closed");
}
if (slack != null) {
return slack.length - begin;
}
if (in.ready()) {
return 1;
} else {
return 0;
}
}
/**
* Closes the Stringreader.
*
* @exception IOException if the original StringReader fails to be closed
*/
public synchronized void close() throws IOException {
if (in != null) {
in.close();
slack = null;
in = null;
}
}
/**
* Resets the StringReader.
*
* @exception IOException if the StringReader fails to be reset
*/
public synchronized void reset() throws IOException {
if (in == null) {
throw new IOException("Stream Closed");
}
slack = null;
in.reset();
}
/**
* Reads from the <code>Reader</code> into a byte array
*
* @param b the byte array to read into
* @param off the offset in the byte array
* @param len the length in the byte array to fill
* @return the actual number read into the byte array, -1 at the end of the stream
* @exception IOException if an error occurs
*/
public synchronized int read(byte[] b, int off, int len) throws IOException {
if (in == null) {
throw new IOException("Stream Closed");
}
if (len == 0) {
return 0;
}
if (encoding == null) {
return castingRead(b, off, len);
}
while (slack == null) {
char[] buf = new char[len]; // might read too much
int n = in.read(buf);
if (n == -1) {
return -1;
}
if (n > 0) {
slack = new String(buf, 0, n).getBytes(encoding);
begin = 0;
}
}
if (len > slack.length - begin) {
len = slack.length - begin;
}
System.arraycopy(slack, begin, b, off, len);
if ((begin += len) >= slack.length) {
slack = null;
}
return len;
}
// Old version simply casts. Must still be used for hashing unless
// change polling version
private int castingRead(byte[] outputBuf, int off, int len) throws IOException {
if (charBuffer == null) {
charBuffer = new char[DEFAULT_BUFFER_CAPACITY];
}
if (len > DEFAULT_BUFFER_CAPACITY) {
len = DEFAULT_BUFFER_CAPACITY;
}
int numRead = in.read(charBuffer, 0, len);
for (int ix = 0; ix < numRead; ix++) {
outputBuf[off + ix] = (byte) charBuffer[ix];
}
return numRead;
}
// Utility methods
// ---------------
// Get the next character, throwing an unchecked exception on error.
private char next() {
try {
int i = (saved != 0) ? saved : r.read();
saved = 0;
if (i <= -1) {
if (body_only) return ']'; // Just a little hacky.
throw eof;
}
return (char) i;
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
}