Back to index...

	/*
	* Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.io;

	/**
	* This class allows an application to create an input stream in
	* which the bytes read are supplied by the contents of a string.
	* Applications can also read bytes from a byte array by using a
	* <code>ByteArrayInputStream</code>.
	* <p>
	* Only the low eight bits of each character in the string are used by
	* this class.
	*
	* @author Arthur van Hoff
	* @see java.io.ByteArrayInputStream
	* @see java.io.StringReader
	* @since 1.0
	* @deprecated This class does not properly convert characters into bytes. As
	* of JDK 1.1, the preferred way to create a stream from a
	* string is via the <code>StringReader</code> class.
	*/
	@Deprecated
	public
	class StringBufferInputStream extends InputStream {
	/**
	* The string from which bytes are read.
	*/
	protected String buffer;

	/**
	* The index of the next character to read from the input stream buffer.
	*
	* @see java.io.StringBufferInputStream#buffer
	*/
	protected int pos;

	/**
	* The number of valid characters in the input stream buffer.
	*
	* @see java.io.StringBufferInputStream#buffer
	*/
	protected int count;

	/**
	* Creates a string input stream to read data from the specified string.
	*
	* @param s the underlying input buffer.
	*/
	public StringBufferInputStream(String s) {
	this.buffer = s;
	count = s.length();
	}

	/**
	* Reads the next byte of data from this input stream. The value
	* byte is returned as an <code>int</code> in the range
	* <code>0</code> to <code>255</code>. If no byte is available
	* because the end of the stream has been reached, the value
	* <code>-1</code> is returned.
	* <p>
	* The <code>read</code> method of
	* <code>StringBufferInputStream</code> cannot block. It returns the
	* low eight bits of the next character in this input stream's buffer.
	*
	* @return the next byte of data, or <code>-1</code> if the end of the
	* stream is reached.
	*/
	public synchronized int read() {
	return (pos < count) ? (buffer.charAt(pos++) & 0xFF) : -1;
	}

	/**
	* Reads up to <code>len</code> bytes of data from this input stream
	* into an array of bytes.
	* <p>
	* The <code>read</code> method of
	* <code>StringBufferInputStream</code> cannot block. It copies the
	* low eight bits from the characters in this input stream's buffer into
	* the byte array argument.
	*
	* @param b the buffer into which the data is read.
	* @param off the start offset of the data.
	* @param len the maximum number of bytes read.
	* @return the total number of bytes read into the buffer, or
	* <code>-1</code> if there is no more data because the end of
	* the stream has been reached.
	*/
	@SuppressWarnings("deprecation")
	public synchronized int read(byte b[], int off, int len) {
	if (b == null) {
	throw new NullPointerException();
	} else if ((off < 0) \|\| (off > b.length) \|\| (len < 0) \|\|
	((off + len) > b.length) \|\| ((off + len) < 0)) {
	throw new IndexOutOfBoundsException();
	}
	if (pos >= count) {
	return -1;
	}

	int avail = count - pos;
	if (len > avail) {
	len = avail;
	}
	if (len <= 0) {
	return 0;
	}
	buffer.getBytes(pos, pos + len, b, off);
	pos += len;
	return len;
	}

	/**
	* Skips <code>n</code> bytes of input from this input stream. Fewer
	* bytes might be skipped if the end of the input stream is reached.
	*
	* @param n the number of bytes to be skipped.
	* @return the actual number of bytes skipped.
	*/
	public synchronized long skip(long n) {
	if (n < 0) {
	return 0;
	}
	if (n > count - pos) {
	n = count - pos;
	}
	pos += n;
	return n;
	}

	/**
	* Returns the number of bytes that can be read from the input
	* stream without blocking.
	*
	* @return the value of <code>count - pos</code>, which is the
	* number of bytes remaining to be read from the input buffer.
	*/
	public synchronized int available() {
	return count - pos;
	}

	/**
	* Resets the input stream to begin reading from the first character
	* of this input stream's underlying buffer.
	*/
	public synchronized void reset() {
	pos = 0;
	}
	}

Back to index...