blob: 3e4c080058b6cd4484161d244e84c21c1e12d2e1 [file] [log] [blame]
package org.apache.roller.weblogger.util.cache;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.roller.util.RollerConstants;
/**
* A utility class for storing cached content written to a java.io.Writer.
*/
public class CachedContent implements Serializable {
private static Log log = LogFactory.getLog(CachedContent.class);
// the byte array we use to maintain the cached content
private byte[] content = new byte[0];
// content-type of data in byte array
private String contentType = null;
// Use a byte array output stream to cached the output bytes
private transient ByteArrayOutputStream outstream = null;
// The PrintWriter that users will be writing to
private transient PrintWriter cachedWriter = null;
public CachedContent(int size) {
// construct output stream
if(size > 0) {
this.outstream = new ByteArrayOutputStream(size);
} else {
this.outstream = new ByteArrayOutputStream(RollerConstants.EIGHT_KB_IN_BYTES);
}
// construct writer from output stream
try {
this.cachedWriter =
new PrintWriter(new OutputStreamWriter(this.outstream, "UTF-8"));
} catch(UnsupportedEncodingException e) {
// shouldn't be possible, java always supports utf-8
throw new RuntimeException("Encoding problem", e);
}
}
public CachedContent(int size, String contentType) {
this(size);
this.contentType = contentType;
}
/**
* Get the content cached in this object as a byte array. If you convert
* this back to a string yourself, be sure to re-encode in "UTF-8".
*
* NOTE: the content is only a representation of the data written to the
* enclosed Writer up until the last call to flush().
*/
public byte[] getContent() {
return this.content;
}
/**
* Get the content cached in this object as a String.
*
* NOTE: the content is only a representation of the data written to the
* enclosed Writer up until the last call to flush().
*/
public String getContentAsString() {
try {
return new String(this.content,"UTF-8");
} catch (UnsupportedEncodingException uex) {
// shouldn't ever happen - violates Java Spec.
throw new RuntimeException(uex);
}
}
public PrintWriter getCachedWriter() {
return cachedWriter;
}
public String getContentType() {
return contentType;
}
/**
* Called to flush any output in the cached Writer to
* the cached content for more permanent storage.
*
* @throws IllegalStateException if calling flush() after a close()
*/
public void flush() {
if(this.outstream == null) {
throw new IllegalStateException("Cannot flush() after a close()!");
}
this.cachedWriter.flush();
this.content = this.outstream.toByteArray();
log.debug("FLUSHED "+this.content.length);
}
/**
* Close this CachedContent from further writing.
*/
public void close() throws IOException {
if(this.cachedWriter != null) {
this.cachedWriter.flush();
this.cachedWriter.close();
this.cachedWriter = null;
}
if(this.outstream != null) {
this.content = this.outstream.toByteArray();
this.outstream.close();
this.outstream = null;
}
log.debug("CLOSED");
}
}