public StringBufferInputStream(String str) 
{
        if (str == null) {
            throw new NullPointerException();
        }
        buffer = str;
        count = str.length();
}

Construct a new {@code StringBufferInputStream} with {@code str} as source. The size of the stream is set to the {@code length()} of the string.

Parameters:

str - the source string for this stream.

Throws:

NullPointerException - if {@code str} is {@code null}.

 public synchronized int available() 
{
        return count - pos;
}

Returns the number of bytes that are available before this stream will block.

 public synchronized int read() 
{
        return pos <  count ? buffer.charAt(pos++) & 0xFF : -1;
}

Reads a single byte from the source string and returns it as an integer in the range from 0 to 255. Returns -1 if the end of the source string has been reached.

 public synchronized int read(byte[] b,
    int offset,
    int length) 
{
        // According to 22.7.6 should return -1 before checking other
        // parameters.
        if (pos  >= count) {
            return -1;
        }
        if (b == null) {
            // luni.11=buffer is null
            throw new NullPointerException(Messages.getString("luni.11")); //$NON-NLS-1$
        }
        // avoid int overflow
        if (offset <  0 || offset  > b.length) {
            // luni.12=Offset out of bounds \: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.12", offset)); //$NON-NLS-1$
        }
        if (length <  0 || length  > b.length - offset) {
            // luni.18=Length out of bounds \: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.18", length)); //$NON-NLS-1$
        }
        if (length == 0) {
            return 0;
        }
        int copylen = count - pos <  length ? count - pos : length;
        for (int i = 0; i <  copylen; i++) {
            b[offset + i] = (byte) buffer.charAt(pos + i);
        }
        pos += copylen;
        return copylen;
}

Reads at most {@code length} bytes from the source string and stores them in the byte array {@code b} starting at {@code offset}.

 public synchronized  void reset() 
{
        pos = 0;
}

Resets this stream to the beginning of the source string.

 public synchronized long skip(long n) 
{
        if (n < = 0) {
            return 0;
        }
        int numskipped;
        if (this.count - pos <  n) {
            numskipped = this.count - pos;
            pos = this.count;
        } else {
            numskipped = (int) n;
            pos += n;
        }
        return numskipped;
}

Skips {@code n} characters in the source string. It does nothing and returns 0 if {@code n} is negative. Less than {@code n} characters are skipped if the end of the source string is reached before the operation completes.