001: /*
002: * Copyright 1994-2006 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: import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
029:
030: /**
031: * A <code>BufferedInputStream</code> adds
032: * functionality to another input stream-namely,
033: * the ability to buffer the input and to
034: * support the <code>mark</code> and <code>reset</code>
035: * methods. When the <code>BufferedInputStream</code>
036: * is created, an internal buffer array is
037: * created. As bytes from the stream are read
038: * or skipped, the internal buffer is refilled
039: * as necessary from the contained input stream,
040: * many bytes at a time. The <code>mark</code>
041: * operation remembers a point in the input
042: * stream and the <code>reset</code> operation
043: * causes all the bytes read since the most
044: * recent <code>mark</code> operation to be
045: * reread before new bytes are taken from
046: * the contained input stream.
047: *
048: * @author Arthur van Hoff
049: * @version 1.63, 05/05/07
050: * @since JDK1.0
051: */
052: public class BufferedInputStream extends FilterInputStream {
053:
054: private static int defaultBufferSize = 8192;
055:
056: /**
057: * The internal buffer array where the data is stored. When necessary,
058: * it may be replaced by another array of
059: * a different size.
060: */
061: protected volatile byte buf[];
062:
063: /**
064: * Atomic updater to provide compareAndSet for buf. This is
065: * necessary because closes can be asynchronous. We use nullness
066: * of buf[] as primary indicator that this stream is closed. (The
067: * "in" field is also nulled out on close.)
068: */
069: private static final AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater = AtomicReferenceFieldUpdater
070: .newUpdater(BufferedInputStream.class, byte[].class, "buf");
071:
072: /**
073: * The index one greater than the index of the last valid byte in
074: * the buffer.
075: * This value is always
076: * in the range <code>0</code> through <code>buf.length</code>;
077: * elements <code>buf[0]</code> through <code>buf[count-1]
078: * </code>contain buffered input data obtained
079: * from the underlying input stream.
080: */
081: protected int count;
082:
083: /**
084: * The current position in the buffer. This is the index of the next
085: * character to be read from the <code>buf</code> array.
086: * <p>
087: * This value is always in the range <code>0</code>
088: * through <code>count</code>. If it is less
089: * than <code>count</code>, then <code>buf[pos]</code>
090: * is the next byte to be supplied as input;
091: * if it is equal to <code>count</code>, then
092: * the next <code>read</code> or <code>skip</code>
093: * operation will require more bytes to be
094: * read from the contained input stream.
095: *
096: * @see java.io.BufferedInputStream#buf
097: */
098: protected int pos;
099:
100: /**
101: * The value of the <code>pos</code> field at the time the last
102: * <code>mark</code> method was called.
103: * <p>
104: * This value is always
105: * in the range <code>-1</code> through <code>pos</code>.
106: * If there is no marked position in the input
107: * stream, this field is <code>-1</code>. If
108: * there is a marked position in the input
109: * stream, then <code>buf[markpos]</code>
110: * is the first byte to be supplied as input
111: * after a <code>reset</code> operation. If
112: * <code>markpos</code> is not <code>-1</code>,
113: * then all bytes from positions <code>buf[markpos]</code>
114: * through <code>buf[pos-1]</code> must remain
115: * in the buffer array (though they may be
116: * moved to another place in the buffer array,
117: * with suitable adjustments to the values
118: * of <code>count</code>, <code>pos</code>,
119: * and <code>markpos</code>); they may not
120: * be discarded unless and until the difference
121: * between <code>pos</code> and <code>markpos</code>
122: * exceeds <code>marklimit</code>.
123: *
124: * @see java.io.BufferedInputStream#mark(int)
125: * @see java.io.BufferedInputStream#pos
126: */
127: protected int markpos = -1;
128:
129: /**
130: * The maximum read ahead allowed after a call to the
131: * <code>mark</code> method before subsequent calls to the
132: * <code>reset</code> method fail.
133: * Whenever the difference between <code>pos</code>
134: * and <code>markpos</code> exceeds <code>marklimit</code>,
135: * then the mark may be dropped by setting
136: * <code>markpos</code> to <code>-1</code>.
137: *
138: * @see java.io.BufferedInputStream#mark(int)
139: * @see java.io.BufferedInputStream#reset()
140: */
141: protected int marklimit;
142:
143: /**
144: * Check to make sure that underlying input stream has not been
145: * nulled out due to close; if not return it;
146: */
147: private InputStream getInIfOpen() throws IOException {
148: InputStream input = in;
149: if (input == null)
150: throw new IOException("Stream closed");
151: return input;
152: }
153:
154: /**
155: * Check to make sure that buffer has not been nulled out due to
156: * close; if not return it;
157: */
158: private byte[] getBufIfOpen() throws IOException {
159: byte[] buffer = buf;
160: if (buffer == null)
161: throw new IOException("Stream closed");
162: return buffer;
163: }
164:
165: /**
166: * Creates a <code>BufferedInputStream</code>
167: * and saves its argument, the input stream
168: * <code>in</code>, for later use. An internal
169: * buffer array is created and stored in <code>buf</code>.
170: *
171: * @param in the underlying input stream.
172: */
173: public BufferedInputStream(InputStream in) {
174: this (in, defaultBufferSize);
175: }
176:
177: /**
178: * Creates a <code>BufferedInputStream</code>
179: * with the specified buffer size,
180: * and saves its argument, the input stream
181: * <code>in</code>, for later use. An internal
182: * buffer array of length <code>size</code>
183: * is created and stored in <code>buf</code>.
184: *
185: * @param in the underlying input stream.
186: * @param size the buffer size.
187: * @exception IllegalArgumentException if size <= 0.
188: */
189: public BufferedInputStream(InputStream in, int size) {
190: super (in);
191: if (size <= 0) {
192: throw new IllegalArgumentException("Buffer size <= 0");
193: }
194: buf = new byte[size];
195: }
196:
197: /**
198: * Fills the buffer with more data, taking into account
199: * shuffling and other tricks for dealing with marks.
200: * Assumes that it is being called by a synchronized method.
201: * This method also assumes that all data has already been read in,
202: * hence pos > count.
203: */
204: private void fill() throws IOException {
205: byte[] buffer = getBufIfOpen();
206: if (markpos < 0)
207: pos = 0; /* no mark: throw away the buffer */
208: else if (pos >= buffer.length) /* no room left in buffer */
209: if (markpos > 0) { /* can throw away early part of the buffer */
210: int sz = pos - markpos;
211: System.arraycopy(buffer, markpos, buffer, 0, sz);
212: pos = sz;
213: markpos = 0;
214: } else if (buffer.length >= marklimit) {
215: markpos = -1; /* buffer got too big, invalidate mark */
216: pos = 0; /* drop buffer contents */
217: } else { /* grow buffer */
218: int nsz = pos * 2;
219: if (nsz > marklimit)
220: nsz = marklimit;
221: byte nbuf[] = new byte[nsz];
222: System.arraycopy(buffer, 0, nbuf, 0, pos);
223: if (!bufUpdater.compareAndSet(this , buffer, nbuf)) {
224: // Can't replace buf if there was an async close.
225: // Note: This would need to be changed if fill()
226: // is ever made accessible to multiple threads.
227: // But for now, the only way CAS can fail is via close.
228: // assert buf == null;
229: throw new IOException("Stream closed");
230: }
231: buffer = nbuf;
232: }
233: count = pos;
234: int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
235: if (n > 0)
236: count = n + pos;
237: }
238:
239: /**
240: * See
241: * the general contract of the <code>read</code>
242: * method of <code>InputStream</code>.
243: *
244: * @return the next byte of data, or <code>-1</code> if the end of the
245: * stream is reached.
246: * @exception IOException if this input stream has been closed by
247: * invoking its {@link #close()} method,
248: * or an I/O error occurs.
249: * @see java.io.FilterInputStream#in
250: */
251: public synchronized int read() throws IOException {
252: if (pos >= count) {
253: fill();
254: if (pos >= count)
255: return -1;
256: }
257: return getBufIfOpen()[pos++] & 0xff;
258: }
259:
260: /**
261: * Read characters into a portion of an array, reading from the underlying
262: * stream at most once if necessary.
263: */
264: private int read1(byte[] b, int off, int len) throws IOException {
265: int avail = count - pos;
266: if (avail <= 0) {
267: /* If the requested length is at least as large as the buffer, and
268: if there is no mark/reset activity, do not bother to copy the
269: bytes into the local buffer. In this way buffered streams will
270: cascade harmlessly. */
271: if (len >= getBufIfOpen().length && markpos < 0) {
272: return getInIfOpen().read(b, off, len);
273: }
274: fill();
275: avail = count - pos;
276: if (avail <= 0)
277: return -1;
278: }
279: int cnt = (avail < len) ? avail : len;
280: System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
281: pos += cnt;
282: return cnt;
283: }
284:
285: /**
286: * Reads bytes from this byte-input stream into the specified byte array,
287: * starting at the given offset.
288: *
289: * <p> This method implements the general contract of the corresponding
290: * <code>{@link InputStream#read(byte[], int, int) read}</code> method of
291: * the <code>{@link InputStream}</code> class. As an additional
292: * convenience, it attempts to read as many bytes as possible by repeatedly
293: * invoking the <code>read</code> method of the underlying stream. This
294: * iterated <code>read</code> continues until one of the following
295: * conditions becomes true: <ul>
296: *
297: * <li> The specified number of bytes have been read,
298: *
299: * <li> The <code>read</code> method of the underlying stream returns
300: * <code>-1</code>, indicating end-of-file, or
301: *
302: * <li> The <code>available</code> method of the underlying stream
303: * returns zero, indicating that further input requests would block.
304: *
305: * </ul> If the first <code>read</code> on the underlying stream returns
306: * <code>-1</code> to indicate end-of-file then this method returns
307: * <code>-1</code>. Otherwise this method returns the number of bytes
308: * actually read.
309: *
310: * <p> Subclasses of this class are encouraged, but not required, to
311: * attempt to read as many bytes as possible in the same fashion.
312: *
313: * @param b destination buffer.
314: * @param off offset at which to start storing bytes.
315: * @param len maximum number of bytes to read.
316: * @return the number of bytes read, or <code>-1</code> if the end of
317: * the stream has been reached.
318: * @exception IOException if this input stream has been closed by
319: * invoking its {@link #close()} method,
320: * or an I/O error occurs.
321: */
322: public synchronized int read(byte b[], int off, int len)
323: throws IOException {
324: getBufIfOpen(); // Check for closed stream
325: if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
326: throw new IndexOutOfBoundsException();
327: } else if (len == 0) {
328: return 0;
329: }
330:
331: int n = 0;
332: for (;;) {
333: int nread = read1(b, off + n, len - n);
334: if (nread <= 0)
335: return (n == 0) ? nread : n;
336: n += nread;
337: if (n >= len)
338: return n;
339: // if not closed but no bytes available, return
340: InputStream input = in;
341: if (input != null && input.available() <= 0)
342: return n;
343: }
344: }
345:
346: /**
347: * See the general contract of the <code>skip</code>
348: * method of <code>InputStream</code>.
349: *
350: * @exception IOException if the stream does not support seek,
351: * or if this input stream has been closed by
352: * invoking its {@link #close()} method, or an
353: * I/O error occurs.
354: */
355: public synchronized long skip(long n) throws IOException {
356: getBufIfOpen(); // Check for closed stream
357: if (n <= 0) {
358: return 0;
359: }
360: long avail = count - pos;
361:
362: if (avail <= 0) {
363: // If no mark position set then don't keep in buffer
364: if (markpos < 0)
365: return getInIfOpen().skip(n);
366:
367: // Fill in buffer to save bytes for reset
368: fill();
369: avail = count - pos;
370: if (avail <= 0)
371: return 0;
372: }
373:
374: long skipped = (avail < n) ? avail : n;
375: pos += skipped;
376: return skipped;
377: }
378:
379: /**
380: * Returns an estimate of the number of bytes that can be read (or
381: * skipped over) from this input stream without blocking by the next
382: * invocation of a method for this input stream. The next invocation might be
383: * the same thread or another thread. A single read or skip of this
384: * many bytes will not block, but may read or skip fewer bytes.
385: * <p>
386: * This method returns the sum of the number of bytes remaining to be read in
387: * the buffer (<code>count - pos</code>) and the result of calling the
388: * {@link java.io.FilterInputStream#in in}.available().
389: *
390: * @return an estimate of the number of bytes that can be read (or skipped
391: * over) from this input stream without blocking.
392: * @exception IOException if this input stream has been closed by
393: * invoking its {@link #close()} method,
394: * or an I/O error occurs.
395: */
396: public synchronized int available() throws IOException {
397: return getInIfOpen().available() + (count - pos);
398: }
399:
400: /**
401: * See the general contract of the <code>mark</code>
402: * method of <code>InputStream</code>.
403: *
404: * @param readlimit the maximum limit of bytes that can be read before
405: * the mark position becomes invalid.
406: * @see java.io.BufferedInputStream#reset()
407: */
408: public synchronized void mark(int readlimit) {
409: marklimit = readlimit;
410: markpos = pos;
411: }
412:
413: /**
414: * See the general contract of the <code>reset</code>
415: * method of <code>InputStream</code>.
416: * <p>
417: * If <code>markpos</code> is <code>-1</code>
418: * (no mark has been set or the mark has been
419: * invalidated), an <code>IOException</code>
420: * is thrown. Otherwise, <code>pos</code> is
421: * set equal to <code>markpos</code>.
422: *
423: * @exception IOException if this stream has not been marked or,
424: * if the mark has been invalidated, or the stream
425: * has been closed by invoking its {@link #close()}
426: * method, or an I/O error occurs.
427: * @see java.io.BufferedInputStream#mark(int)
428: */
429: public synchronized void reset() throws IOException {
430: getBufIfOpen(); // Cause exception if closed
431: if (markpos < 0)
432: throw new IOException("Resetting to invalid mark");
433: pos = markpos;
434: }
435:
436: /**
437: * Tests if this input stream supports the <code>mark</code>
438: * and <code>reset</code> methods. The <code>markSupported</code>
439: * method of <code>BufferedInputStream</code> returns
440: * <code>true</code>.
441: *
442: * @return a <code>boolean</code> indicating if this stream type supports
443: * the <code>mark</code> and <code>reset</code> methods.
444: * @see java.io.InputStream#mark(int)
445: * @see java.io.InputStream#reset()
446: */
447: public boolean markSupported() {
448: return true;
449: }
450:
451: /**
452: * Closes this input stream and releases any system resources
453: * associated with the stream.
454: * Once the stream has been closed, further read(), available(), reset(),
455: * or skip() invocations will throw an IOException.
456: * Closing a previously closed stream has no effect.
457: *
458: * @exception IOException if an I/O error occurs.
459: */
460: public void close() throws IOException {
461: byte[] buffer;
462: while ((buffer = buf) != null) {
463: if (bufUpdater.compareAndSet(this , buffer, null)) {
464: InputStream input = in;
465: in = null;
466: if (input != null)
467: input.close();
468: return;
469: }
470: // Else retry in case a new buf was CASed in fill()
471: }
472: }
473: }
|
