001: /*
002: * @(#)StringReader.java 1.22 06/10/10
003: *
004: * Copyright 1990-2006 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: *
026: */
027:
028: package java.io;
029:
030: /**
031: * A character stream whose source is a string.
032: *
033: * @version 1.15, 00/02/02
034: * @author Mark Reinhold
035: * @since JDK1.1
036: */
037:
038: public class StringReader extends Reader {
039:
040: private String str;
041: private int length;
042: private int next = 0;
043: private int mark = 0;
044:
045: /**
046: * Create a new string reader.
047: *
048: * @param s String providing the character stream.
049: */
050: public StringReader(String s) {
051: this .str = s;
052: this .length = s.length();
053: }
054:
055: /** Check to make sure that the stream has not been closed */
056: private void ensureOpen() throws IOException {
057: if (str == null)
058: throw new IOException("Stream closed");
059: }
060:
061: /**
062: * Read a single character.
063: *
064: * @return The character read, or -1 if the end of the stream has been
065: * reached
066: *
067: * @exception IOException If an I/O error occurs
068: */
069: public int read() throws IOException {
070: synchronized (lock) {
071: ensureOpen();
072: if (next >= length)
073: return -1;
074: return str.charAt(next++);
075: }
076: }
077:
078: /**
079: * Read characters into a portion of an array.
080: *
081: * @param cbuf Destination buffer
082: * @param off Offset at which to start writing characters
083: * @param len Maximum number of characters to read
084: *
085: * @return The number of characters read, or -1 if the end of the
086: * stream has been reached
087: *
088: * @exception IOException If an I/O error occurs
089: */
090: public int read(char cbuf[], int off, int len) throws IOException {
091: synchronized (lock) {
092: ensureOpen();
093: if ((off < 0) || (off > cbuf.length) || (len < 0)
094: || ((off + len) > cbuf.length) || ((off + len) < 0)) {
095: throw new IndexOutOfBoundsException();
096: } else if (len == 0) {
097: return 0;
098: }
099: if (next >= length)
100: return -1;
101: int n = Math.min(length - next, len);
102: str.getChars(next, next + n, cbuf, off);
103: next += n;
104: return n;
105: }
106: }
107:
108: /**
109: * Skip characters.
110: *
111: * @exception IOException If an I/O error occurs
112: */
113: public long skip(long ns) throws IOException {
114: synchronized (lock) {
115: ensureOpen();
116: if (next >= length)
117: return 0;
118: long n = Math.min(length - next, ns);
119: next += n;
120: return n;
121: }
122: }
123:
124: /**
125: * Tell whether this stream is ready to be read.
126: *
127: * @return True if the next read() is guaranteed not to block for input
128: *
129: * @exception IOException If the stream is closed
130: */
131: public boolean ready() throws IOException {
132: synchronized (lock) {
133: ensureOpen();
134: return true;
135: }
136: }
137:
138: /**
139: * Tell whether this stream supports the mark() operation, which it does.
140: */
141: public boolean markSupported() {
142: return true;
143: }
144:
145: /**
146: * Mark the present position in the stream. Subsequent calls to reset()
147: * will reposition the stream to this point.
148: *
149: * @param readAheadLimit Limit on the number of characters that may be
150: * read while still preserving the mark. Because
151: * the stream's input comes from a string, there
152: * is no actual limit, so this argument must not
153: * be negative, but is otherwise ignored.
154: *
155: * @exception IllegalArgumentException If readAheadLimit is < 0
156: * @exception IOException If an I/O error occurs
157: */
158: public void mark(int readAheadLimit) throws IOException {
159: if (readAheadLimit < 0) {
160: throw new IllegalArgumentException("Read-ahead limit < 0");
161: }
162: synchronized (lock) {
163: ensureOpen();
164: mark = next;
165: }
166: }
167:
168: /**
169: * Reset the stream to the most recent mark, or to the beginning of the
170: * string if it has never been marked.
171: *
172: * @exception IOException If an I/O error occurs
173: */
174: public void reset() throws IOException {
175: synchronized (lock) {
176: ensureOpen();
177: next = mark;
178: }
179: }
180:
181: /**
182: * Close the stream.
183: */
184: public void close() {
185: str = null;
186: }
187:
188: }
|