/*
* 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 ImageOutputStream that writes its
output to a regular OutputStream. 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
OutputStream, 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.
/**
* 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 MemoryCacheImageOutputStream that will write
to a given OutputStream.
Params: - stream – an
OutputStream to write to.
Throws: - IllegalArgumentException – if
stream is
null.
/**
* 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 true since this
ImageOutputStream caches data in order to allow
seeking backwards.
See Also: Returns: true.
/**
* 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 false since this
ImageOutputStream does not maintain a file cache.
See Also: Returns: false.
/**
* 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 true since this
ImageOutputStream maintains a main memory cache.
See Also: Returns: true.
/**
* 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 MemoryCacheImageOutputStream. All
pending data is flushed to the output, and the cache
is released. The destination OutputStream
is not closed.
/**
* 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();
}
}