001: /*
002: * Copyright 1996-2004 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package java.io;
027:
028: /**
029: * A character stream that collects its output in a string buffer, which can
030: * then be used to construct a string.
031: * <p>
032: * Closing a <tt>StringWriter</tt> has no effect. The methods in this class
033: * can be called after the stream has been closed without generating an
034: * <tt>IOException</tt>.
035: *
036: * @version 1.32, 07/05/05
037: * @author Mark Reinhold
038: * @since JDK1.1
039: */
040:
041: public class StringWriter extends Writer {
042:
043: private StringBuffer buf;
044:
045: /**
046: * Create a new string writer using the default initial string-buffer
047: * size.
048: */
049: public StringWriter() {
050: buf = new StringBuffer();
051: lock = buf;
052: }
053:
054: /**
055: * Create a new string writer using the specified initial string-buffer
056: * size.
057: *
058: * @param initialSize
059: * The number of <tt>char</tt> values that will fit into this buffer
060: * before it is automatically expanded
061: *
062: * @throws IllegalArgumentException
063: * If <tt>initialSize</tt> is negative
064: */
065: public StringWriter(int initialSize) {
066: if (initialSize < 0) {
067: throw new IllegalArgumentException("Negative buffer size");
068: }
069: buf = new StringBuffer(initialSize);
070: lock = buf;
071: }
072:
073: /**
074: * Write a single character.
075: */
076: public void write(int c) {
077: buf.append((char) c);
078: }
079:
080: /**
081: * Write a portion of an array of characters.
082: *
083: * @param cbuf Array of characters
084: * @param off Offset from which to start writing characters
085: * @param len Number of characters to write
086: */
087: public void write(char cbuf[], int off, int len) {
088: if ((off < 0) || (off > cbuf.length) || (len < 0)
089: || ((off + len) > cbuf.length) || ((off + len) < 0)) {
090: throw new IndexOutOfBoundsException();
091: } else if (len == 0) {
092: return;
093: }
094: buf.append(cbuf, off, len);
095: }
096:
097: /**
098: * Write a string.
099: */
100: public void write(String str) {
101: buf.append(str);
102: }
103:
104: /**
105: * Write a portion of a string.
106: *
107: * @param str String to be written
108: * @param off Offset from which to start writing characters
109: * @param len Number of characters to write
110: */
111: public void write(String str, int off, int len) {
112: buf.append(str.substring(off, off + len));
113: }
114:
115: /**
116: * Appends the specified character sequence to this writer.
117: *
118: * <p> An invocation of this method of the form <tt>out.append(csq)</tt>
119: * behaves in exactly the same way as the invocation
120: *
121: * <pre>
122: * out.write(csq.toString()) </pre>
123: *
124: * <p> Depending on the specification of <tt>toString</tt> for the
125: * character sequence <tt>csq</tt>, the entire sequence may not be
126: * appended. For instance, invoking the <tt>toString</tt> method of a
127: * character buffer will return a subsequence whose content depends upon
128: * the buffer's position and limit.
129: *
130: * @param csq
131: * The character sequence to append. If <tt>csq</tt> is
132: * <tt>null</tt>, then the four characters <tt>"null"</tt> are
133: * appended to this writer.
134: *
135: * @return This writer
136: *
137: * @since 1.5
138: */
139: public StringWriter append(CharSequence csq) {
140: if (csq == null)
141: write("null");
142: else
143: write(csq.toString());
144: return this ;
145: }
146:
147: /**
148: * Appends a subsequence of the specified character sequence to this writer.
149: *
150: * <p> An invocation of this method of the form <tt>out.append(csq, start,
151: * end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
152: * exactly the same way as the invocation
153: *
154: * <pre>
155: * out.write(csq.subSequence(start, end).toString()) </pre>
156: *
157: * @param csq
158: * The character sequence from which a subsequence will be
159: * appended. If <tt>csq</tt> is <tt>null</tt>, then characters
160: * will be appended as if <tt>csq</tt> contained the four
161: * characters <tt>"null"</tt>.
162: *
163: * @param start
164: * The index of the first character in the subsequence
165: *
166: * @param end
167: * The index of the character following the last character in the
168: * subsequence
169: *
170: * @return This writer
171: *
172: * @throws IndexOutOfBoundsException
173: * If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
174: * is greater than <tt>end</tt>, or <tt>end</tt> is greater than
175: * <tt>csq.length()</tt>
176: *
177: * @since 1.5
178: */
179: public StringWriter append(CharSequence csq, int start, int end) {
180: CharSequence cs = (csq == null ? "null" : csq);
181: write(cs.subSequence(start, end).toString());
182: return this ;
183: }
184:
185: /**
186: * Appends the specified character to this writer.
187: *
188: * <p> An invocation of this method of the form <tt>out.append(c)</tt>
189: * behaves in exactly the same way as the invocation
190: *
191: * <pre>
192: * out.write(c) </pre>
193: *
194: * @param c
195: * The 16-bit character to append
196: *
197: * @return This writer
198: *
199: * @since 1.5
200: */
201: public StringWriter append(char c) {
202: write(c);
203: return this ;
204: }
205:
206: /**
207: * Return the buffer's current value as a string.
208: */
209: public String toString() {
210: return buf.toString();
211: }
212:
213: /**
214: * Return the string buffer itself.
215: *
216: * @return StringBuffer holding the current buffer value.
217: */
218: public StringBuffer getBuffer() {
219: return buf;
220: }
221:
222: /**
223: * Flush the stream.
224: */
225: public void flush() {
226: }
227:
228: /**
229: * Closing a <tt>StringWriter</tt> has no effect. The methods in this
230: * class can be called after the stream has been closed without generating
231: * an <tt>IOException</tt>.
232: */
233: public void close() throws IOException {
234: }
235:
236: }
| 