/* * Copyright (c) 2000, 2006, 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 javax.imageio.stream; import java.io.IOException;import java.io.OutputStream; /** * An implementation of <code>ImageOutputStream</code> that writes its * output to a regular <code>OutputStream</code>.  A memory buffer is * used to cache at least the data between the discard position and * the current write position.  The only constructor takes an * <code>OutputStream</code>, so this class may not be used for * read/modify/write operations.  Reading can occur only on parts of * the stream that have already been written to the cache and not * yet flushed. * */public class MemoryCacheImageOutputStream extends ImageOutputStreamImpl {     private OutputStream stream;     private MemoryCache cache = new MemoryCache();     /**     * Constructs a <code>MemoryCacheImageOutputStream</code> that will write     * to a given <code>OutputStream</code>.     *     * @param stream an <code>OutputStream</code> to write to.     *     * @exception IllegalArgumentException if <code>stream</code> is     * <code>null</code>.     */    public MemoryCacheImageOutputStream(OutputStream stream) {        if (stream == null) {            throw new IllegalArgumentException("stream == null!");        }        this.stream = stream;    }     public int read() throws IOException {        checkClosed();         bitOffset = 0;         int val = cache.read(streamPos);        if (val != -1) {            ++streamPos;        }        return val;    }     public int read(byte[] b, int off, int len) throws IOException {        checkClosed();         if (b == null) {            throw new NullPointerException("b == null!");        }        // Fix 4467608: read([B,I,I) works incorrectly if len<=0        if (off < 0 || len < 0 || off + len > b.length || off + len < 0) {            throw new IndexOutOfBoundsException                ("off < 0 || len < 0 || off+len > b.length || off+len < 0!");        }         bitOffset = 0;         if (len == 0) {            return 0;        }         // check if we're already at/past EOF i.e.        // no more bytes left to read from cache        long bytesLeftInCache = cache.getLength() - streamPos;        if (bytesLeftInCache <= 0) {            return -1; // EOF        }         // guaranteed by now that bytesLeftInCache > 0 && len > 0        // and so the rest of the error checking is done by cache.read()        // NOTE that alot of error checking is duplicated        len = (int)Math.min(bytesLeftInCache, (long)len);        cache.read(b, off, len, streamPos);        streamPos += len;        return len;    }     public void write(int b) throws IOException {        flushBits(); // this will call checkClosed() for us        cache.write(b, streamPos);        ++streamPos;    }     public void write(byte[] b, int off, int len) throws IOException {        flushBits(); // this will call checkClosed() for us        cache.write(b, off, len, streamPos);        streamPos += len;    }     public long length() {        try {            checkClosed();            return cache.getLength();        } catch (IOException e) {            return -1L;        }    }     /**     * Returns <code>true</code> since this     * <code>ImageOutputStream</code> caches data in order to allow     * seeking backwards.     *     * @return <code>true</code>.     *     * @see #isCachedMemory     * @see #isCachedFile     */    public boolean isCached() {        return true;    }     /**     * Returns <code>false</code> since this     * <code>ImageOutputStream</code> does not maintain a file cache.     *     * @return <code>false</code>.     *     * @see #isCached     * @see #isCachedMemory     */    public boolean isCachedFile() {        return false;    }     /**     * Returns <code>true</code> since this     * <code>ImageOutputStream</code> maintains a main memory cache.     *     * @return <code>true</code>.     *     * @see #isCached     * @see #isCachedFile     */    public boolean isCachedMemory() {        return true;    }     /**     * Closes this <code>MemoryCacheImageOutputStream</code>.  All     * pending data is flushed to the output, and the cache     * is released.  The destination <code>OutputStream</code>     * is not closed.     */    public void close() throws IOException {        long length = cache.getLength();        seek(length);        flushBefore(length);        super.close();        cache.reset();        cache = null;        stream = null;    }     public void flushBefore(long pos) throws IOException {        long oFlushedPos = flushedPos;        super.flushBefore(pos); // this will call checkClosed() for us         long flushBytes = flushedPos - oFlushedPos;        cache.writeToStream(stream, oFlushedPos, flushBytes);        cache.disposeBefore(flushedPos);        stream.flush();    }}