FileDocCategorySizeDatePackage
StringBufferInputStream.javaAPI DocAndroid 1.5 API6033Wed May 06 22:41:04 BST 2009java.io

StringBufferInputStream

public class StringBufferInputStream extends InputStream
A specialized {@link InputStream} that reads bytes from a {@code String} in a sequential manner.
deprecated
Use {@link StringReader}
since
Android 1.0

Fields Summary
protected String
buffer
The source string containing the data to read.
protected int
count
The total number of characters in the source string.
protected int
pos
The current position within the source string.
Constructors Summary
public StringBufferInputStream(String str)
Construct a new {@code StringBufferInputStream} with {@code str} as source. The size of the stream is set to the {@code length()} of the string.

param
str the source string for this stream.
throws
NullPointerException if {@code str} is {@code null}.
since
Android 1.0

        if (str == null) {
            throw new NullPointerException();
        }
        buffer = str;
        count = str.length();
    
Methods Summary
public synchronized intavailable()
Returns the number of bytes that are available before this stream will block.

return
the number of bytes available before blocking.
since
Android 1.0

        return count - pos;
    
public synchronized intread()
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.

return
the byte read or -1 if the end of the source string has been reached.
since
Android 1.0

        return pos < count ? buffer.charAt(pos++) & 0xFF : -1;
    
public synchronized intread(byte[] b, int offset, int length)
Reads at most {@code length} bytes from the source string and stores them in the byte array {@code b} starting at {@code offset}.

param
b the byte array in which to store the bytes read.
param
offset the initial position in {@code b} to store the bytes read from this stream.
param
length the maximum number of bytes to store in {@code b}.
return
the number of bytes actually read or -1 if the end of the source string has been reached.
throws
IndexOutOfBoundsException if {@code offset < 0} or {@code length < 0}, or if {@code offset + length} is greater than the length of {@code b}.
throws
NullPointerException if {@code b} is {@code null}.
since
Android 1.0

        // BEGIN android-note
        // changed array notation to be consistent with the rest of harmony
        // END android-note
        // According to 22.7.6 should return -1 before checking other
        // parameters.
        if (pos >= count) {
            return -1;
        }
        if (b == null) {
            throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
        }
        // avoid int overflow
        // BEGIN android-changed
        // Exception priorities (in case of multiple errors) differ from
        // RI, but are spec-compliant.
        // removed redundant check, used (offset | length) < 0
        // instead of (offset < 0) || (length < 0) to safe one operation
        if ((offset | length) < 0 || length > b.length - offset) {
            throw new ArrayIndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
        }
        // END android-changed
        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;
    
public synchronized voidreset()
Resets this stream to the beginning of the source string.

since
Android 1.0

        pos = 0;
    
public synchronized longskip(long n)
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.

param
n the number of characters to skip.
return
the number of characters actually skipped.
since
Android 1.0

        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;