001: /*
002: *
003: *
004: * Copyright 1990-2007 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: package java.io;
028:
029: import com.sun.cldchi.jvm.JVM;
030:
031: /**
032: * This class implements an output stream in which the data is
033: * written into a byte array. The buffer automatically grows as data
034: * is written to it.
035: * The data can be retrieved using <code>toByteArray()</code> and
036: * <code>toString()</code>.
037: * @version 12/17/01 (CLDC 1.1)
038: * @since JDK1.0, CLDC 1.0
039: */
040:
041: public class ByteArrayOutputStream extends OutputStream {
042:
043: /**
044: * The buffer where data is stored.
045: */
046: protected byte buf[];
047:
048: /**
049: * The number of valid bytes in the buffer.
050: */
051: protected int count;
052:
053: /**
054: * Flag indicating whether the stream has been closed.
055: */
056: private boolean isClosed = false;
057:
058: /**
059: * Creates a new byte array output stream. The buffer capacity is
060: * initially 32 bytes, though its size increases if necessary.
061: */
062: public ByteArrayOutputStream() {
063: this (32);
064: }
065:
066: /**
067: * Creates a new byte array output stream, with a buffer capacity of
068: * the specified size, in bytes.
069: *
070: * @param size the initial size.
071: * @exception IllegalArgumentException if size is negative.
072: */
073: public ByteArrayOutputStream(int size) {
074: if (size < 0) {
075: throw new IllegalArgumentException(
076: /* #ifdef VERBOSE_EXCEPTIONS */
077: /// skipped "Negative initial size: " + size
078: /* #endif */
079: );
080: }
081: buf = new byte[size];
082: }
083:
084: /**
085: * Writes the specified byte to this byte array output stream.
086: *
087: * @param b the byte to be written.
088: */
089: public synchronized void write(int b) {
090: int newcount = count + 1;
091: if (newcount > buf.length) {
092: byte newbuf[] = new byte[Math
093: .max(buf.length << 1, newcount)];
094: JVM.unchecked_byte_arraycopy(buf, 0, newbuf, 0, count);
095: buf = newbuf;
096: }
097: buf[count] = (byte) b;
098: count = newcount;
099: }
100:
101: /**
102: * Writes <code>len</code> bytes from the specified byte array
103: * starting at offset <code>off</code> to this byte array output stream.
104: *
105: * @param b the data.
106: * @param off the start offset in the data.
107: * @param len the number of bytes to write.
108: */
109: public synchronized void write(byte b[], int off, int len) {
110: if ((off < 0) || (off > b.length) || (len < 0)
111: || ((off + len) > b.length) || ((off + len) < 0)) {
112: throw new IndexOutOfBoundsException();
113: } else if (len == 0) {
114: return;
115: }
116: int newcount = count + len;
117: if (newcount > buf.length) {
118: byte newbuf[] = new byte[Math
119: .max(buf.length << 1, newcount)];
120: JVM.unchecked_byte_arraycopy(buf, 0, newbuf, 0, count);
121: buf = newbuf;
122: }
123: JVM.unchecked_byte_arraycopy(b, off, buf, count, len);
124: count = newcount;
125: }
126:
127: /**
128: * Resets the <code>count</code> field of this byte array output
129: * stream to zero, so that all currently accumulated output in the
130: * output stream is discarded. The output stream can be used again,
131: * reusing the already allocated buffer space.
132: *
133: * @see java.io.ByteArrayInputStream#count
134: */
135: public synchronized void reset() {
136: count = 0;
137: }
138:
139: /**
140: * Creates a newly allocated byte array. Its size is the current
141: * size of this output stream and the valid contents of the buffer
142: * have been copied into it.
143: *
144: * @return the current contents of this output stream, as a byte array.
145: * @see java.io.ByteArrayOutputStream#size()
146: */
147: public synchronized byte toByteArray()[] {
148: if (isClosed && buf.length == count) {
149: return buf;
150: } else {
151: byte newbuf[] = new byte[count];
152: JVM.unchecked_byte_arraycopy(buf, 0, newbuf, 0, count);
153: return newbuf;
154: }
155: }
156:
157: /**
158: * Returns the current size of the buffer.
159: *
160: * @return the value of the <code>count</code> field, which is the number
161: * of valid bytes in this output stream.
162: * @see java.io.ByteArrayOutputStream#count
163: */
164: public int size() {
165: return count;
166: }
167:
168: /**
169: * Converts the buffer's contents into a string, translating bytes into
170: * characters according to the platform's default character encoding.
171: *
172: * @return String translated from the buffer's contents.
173: * @since JDK1.1
174: */
175: public String toString() {
176: return new String(buf, 0, count);
177: }
178:
179: /**
180: * Closes this output stream and releases any system resources
181: * associated with this stream. A closed stream cannot perform
182: * output operations and cannot be reopened.
183: * <p>
184: *
185: */
186: public synchronized void close() throws IOException {
187: isClosed = true;
188: }
189:
190: }
|