public FileCacheImageInputStream(InputStream stream,
    File cacheDir) throws IOException 
{
                                                                                                                  
        if (stream == null) {
            throw new IllegalArgumentException("stream == null!");
        }
        if ((cacheDir != null) && !(cacheDir.isDirectory())) {
            throw new IllegalArgumentException("Not a directory!");
        }
        this.stream = stream;
        this.cacheFile =
            File.createTempFile("imageio", ".tmp", cacheDir);
        this.cache = new RandomAccessFile(cacheFile, "rw");
        StreamCloser.addToQueue(this);
        disposerRecord = new StreamDisposerRecord(cacheFile, cache);
        if (getClass() == FileCacheImageInputStream.class) {
            disposerReferent = new Object();
            Disposer.addRecord(disposerReferent, disposerRecord);
        } else {
            disposerReferent = new StreamFinalizer(this);
        }
}

Constructs a FileCacheImageInputStream that will read from a given InputStream.

A temporary file is used as a cache. If cacheDiris non-null and is a directory, the file will be created there. If it is null, the system-dependent default temporary-file directory will be used (see the documentation for File.createTempFile for details).

Parameters:

stream - an InputStream to read from.

cacheDir - a File indicating where the cache file should be created, or null to use the system directory.

Throws:

IllegalArgumentException - if stream is null.

IllegalArgumentException - if cacheDir is non-null but is not a directory.

IOException - if a cache file cannot be created.

exception: IllegalArgumentException - if stream is null.

exception: IllegalArgumentException - if cacheDir is non-null but is not a directory.

exception: IOException - if a cache file cannot be created.

 public  void close() throws IOException 
{
        super.close();
        disposerRecord.dispose(); // this will close/delete the cache file
        stream = null;
        cache = null;
        cacheFile = null;
        StreamCloser.removeFromQueue(this);
}

Closes this FileCacheImageInputStream, closing and removing the cache file. The source InputStream is not closed.

 protected  void finalize() throws Throwable 
{
        // Empty finalizer: for performance reasons we instead use the
        // Disposer mechanism for ensuring that the underlying
        // RandomAccessFile is closed/deleted prior to garbage collection
}

{@inheritDoc}

 public boolean isCached() 
{
        return true;
}

Returns true since this ImageInputStream caches data in order to allow seeking backwards.

 public boolean isCachedFile() 
{
        return true;
}

Returns true since this ImageInputStream maintains a file cache.

 public boolean isCachedMemory() 
{
        return false;
}

Returns false since this ImageInputStream does not maintain a main memory cache.

 public int read() throws IOException 
{
        checkClosed();
        bitOffset = 0;
        long next = streamPos + 1;
        long pos = readUntil(next);
        if (pos  >= next) {
            cache.seek(streamPos++);
            return cache.read();
        } else {
            return -1;
        }
}

 public int read(byte[] b,
    int off,
    int len) throws IOException 
{
        checkClosed();
        if (b == null) {
            throw new NullPointerException("b == null!");
        }
        // Fix 4430357 - if off + len <  0, overflow occurred
        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 = readUntil(streamPos + len);
        // len will always fit into an int so this is safe
        len = (int)Math.min((long)len, pos - streamPos);
        if (len  > 0) {
            cache.seek(streamPos);
            cache.readFully(b, off, len);
            streamPos += len;
            return len;
        } else {
            return -1;
        }
}