/*

 * Copyright (c) 2000, 2007, 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.InputStream;

import java.io.IOException;

import com.sun.imageio.stream.StreamFinalizer;

import sun.java2d.Disposer;

import sun.java2d.DisposerRecord;

/**

 * An implementation of <code>ImageInputStream</code> that gets its

 * input from a regular <code>InputStream</code>.  A memory buffer is

 * used to cache at least the data between the discard position and

 * the current read position.

 *

 * <p> In general, it is preferable to use a

 * <code>FileCacheImageInputStream</code> when reading from a regular

 * <code>InputStream</code>.  This class is provided for cases where

 * it is not possible to create a writable temporary file.

 *

 */

public class MemoryCacheImageInputStream extends ImageInputStreamImpl {

    private InputStream stream;

    private MemoryCache cache = new MemoryCache();

    /** The referent to be registered with the Disposer. */

    private final Object disposerReferent;

    /** The DisposerRecord that resets the underlying MemoryCache. */

    private final DisposerRecord disposerRecord;

    /**

     * Constructs a <code>MemoryCacheImageInputStream</code> that will read

     * from a given <code>InputStream</code>.

     *

     * @param stream an <code>InputStream</code> to read from.

     *

     * @exception IllegalArgumentException if <code>stream</code> is

     * <code>null</code>.

     */

    public MemoryCacheImageInputStream(InputStream stream) {

        if (stream == null) {

            throw new IllegalArgumentException("stream == null!");

        }

        this.stream = stream;

        disposerRecord = new StreamDisposerRecord(cache);

        if (getClass() == MemoryCacheImageInputStream.class) {

            disposerReferent = new Object();

            Disposer.addRecord(disposerReferent, disposerRecord);

        } else {

            disposerReferent = new StreamFinalizer(this);

        }

    }

    public int read() throws IOException {

        checkClosed();

        bitOffset = 0;

        long pos = cache.loadFromStream(stream, streamPos+1);

        if (pos >= streamPos+1) {

            return cache.read(streamPos++);

        } else {

            return -1;

        }

    }

    public int read(byte[] b, int off, int len) throws IOException {

        checkClosed();

        if (b == null) {

            throw new NullPointerException("b == null!");

        }

        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;

        }

        long pos = cache.loadFromStream(stream, streamPos+len);

        len = (int)(pos - streamPos);  // In case stream ended early

        if (len > 0) {

            cache.read(b, off, len, streamPos);

            streamPos += len;

            return len;

        } else {

            return -1;

        }

    }

    public void flushBefore(long pos) throws IOException {

        super.flushBefore(pos); // this will call checkClosed() for us

        cache.disposeBefore(pos);

    }

    /**

     * Returns <code>true</code> since this

     * <code>ImageInputStream</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>ImageInputStream</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>ImageInputStream</code> maintains a main memory cache.

     *

     * @return <code>true</code>.

     *

     * @see #isCached

     * @see #isCachedFile

     */

    public boolean isCachedMemory() {

        return true;

    }

    /**

     * Closes this <code>MemoryCacheImageInputStream</code>, freeing

     * the cache.  The source <code>InputStream</code> is not closed.

     */

    public void close() throws IOException {

        super.close();

        disposerRecord.dispose(); // this resets the MemoryCache

        stream = null;

        cache = null;

    }

    /**

     * {@inheritDoc}

     */

    protected void finalize() throws Throwable {

        // Empty finalizer: for performance reasons we instead use the

        // Disposer mechanism for ensuring that the underlying

        // MemoryCache is reset prior to garbage collection

    }

    private static class StreamDisposerRecord implements DisposerRecord {

        private MemoryCache cache;

        public StreamDisposerRecord(MemoryCache cache) {

            this.cache = cache;

        }

        public synchronized void dispose() {

            if (cache != null) {

                cache.reset();

                cache = null;

            }

        }

    }

}