org.ajax4jsf.framework.ajax.xmlfilter.CacheContent Maven / Gradle / Ivy

/**
 * Licensed under the Common Development and Distribution License,
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.sun.com/cddl/
 *   
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

package org.ajax4jsf.framework.ajax.xmlfilter;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import org.ajax4jsf.io.FastBufferOutputStream;
import org.ajax4jsf.io.FastBufferWriter;

/**
 * @author shura (latest modification by $Author: alexsmirnov $)
 * @version $Revision: 1.9 $ $Date: 2007/01/05 20:24:53 $
 *
 */
public class CacheContent implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 8120940486890871177L;
//	private transient ByteArrayOutputStream outputStream ;
	private transient FastBufferOutputStream outputStream ;
	private transient FastBufferWriter stringOutputWriter;
	private transient PrintWriter servletWriter;
	private transient ServletOutputStream servletStream;
	// content to send.
	private byte[] content = null;
	private String writerContent = null;

	boolean filledOutputStream = false;
	boolean filledOutputWriter = false;
	private Map headers = new HashMap();
	private String contentType;
	
	/**
	 * Send saved content to http responce
	 * @param response
	 * @throws IOException
	 */
	public void send(HttpServletResponse response) throws IOException{
		if (filledOutputStream) {
			OutputStream out = response.getOutputStream();
			if(content != null) {
				out.write(content);
			} else {
				this.outputStream.writeTo(out);
			}
//			out.flush();
//			out.close();
		} else if (filledOutputWriter) {
			Writer out = response.getWriter();
			if (null != writerContent) {
				out.write(writerContent);
			} else {
				stringOutputWriter.writeTo(out);
			}
//			out.flush();
//			out.close();
		}
	}
	
	/**
	 * Send saved headers to http responce.
	 * @param response
	 */
	public void sendHeaders(HttpServletResponse response){
		for (Iterator iter = headers.entrySet().iterator(); iter.hasNext();) {
			Map.Entry element = (Map.Entry) iter.next();
			String header = (String) element.getKey();
			if (element.getValue() instanceof Long) {
				Long time = (Long) element.getValue();
				response.setDateHeader(header,time.longValue());
			} else if (element.getValue() instanceof Integer) {
				Integer value = (Integer) element.getValue();
				response.setIntHeader(header,value.intValue());
			} else {
				response.setHeader(header,(String) element.getValue());
			}
			// set real content-length.
			
///			if (null != content) {
			if (filledOutputStream) {
///				response.setIntHeader("Content-Length", content.length);
				response.setIntHeader("Content-Length", outputStream.getLength());
			} // TODO - calculate content-lenght for writer ?
			if( null != contentType){
				response.setContentType(this.contentType);
			}
		}
	}
	
	public void setDateHeader(String name, long value) {
		// Expires not stored in cache - must be re-calculated for every response.
		if(!"Expires".equals(name)){
			headers.put(name, new Long(value));
		}
	}

	/* (non-Javadoc)
	 * @see org.ajax4jsf.framework.resource.ResourceContext#setHeader(java.lang.String, java.lang.String)
	 */
	public void setHeader(String name, String value) {
		headers.put(name,value);
	}

	/* (non-Javadoc)
	 * @see org.ajax4jsf.framework.resource.ResourceContext#setIntHeader(java.lang.String, int)
	 */
	public void setIntHeader(String name, int value) {
		headers.put(name, new Integer(value));
	}

	/**
	 * Create UNIX command 'tee' like stream - send all data to servlet 
	 * @param responseStream
	 * @return
	 */
	public OutputStream getOutputStream(final OutputStream responseStream){
		if (null == servletStream) {
			outputStream = new FastBufferOutputStream(1024);
			servletStream = new ServletOutputStream(){
				
				/* (non-Javadoc)
				* @see java.io.OutputStream#close()
				*/
				public void close() throws IOException {
					filledOutputStream = true;
///					content  = outputStream.toByteArray();
					responseStream.close();
					content = null;
				}
				
				/* (non-Javadoc)
				* @see java.io.OutputStream#flush()
				*/
				public void flush() throws IOException {
					responseStream.flush();
				}
				
				/* (non-Javadoc)
				* @see java.io.OutputStream#write(byte[], int, int)
				*/
				public void write(byte[] b, int off, int len) throws IOException {
					outputStream.write(b, off, len);
					responseStream.write(b, off, len);
				}
				
				/* (non-Javadoc)
				* @see java.io.OutputStream#write(byte[])
				*/
				public void write(byte[] b) throws IOException {
					outputStream.write(b);
					responseStream.write(b);
				}
				
				public void write(int b) throws IOException {
					outputStream.write(b);
					responseStream.write(b);
				}
				
			};
		}
		return servletStream;
	}
	
	public PrintWriter getWriter( final Writer responseWriter) {
		if (null == servletWriter) {
			stringOutputWriter = new FastBufferWriter(1024);
			Writer out = new Writer() {

				public void write(char[] cbuf, int off, int len)
						throws IOException {
					responseWriter.write(cbuf, off, len);
					stringOutputWriter.write(cbuf, off, len);
				}

				public void flush() throws IOException {
					responseWriter.flush();
				}

				public void close() throws IOException {
					responseWriter.close();
///					writerContent = stringOutputWriter.toString();
					filledOutputWriter = true;
					writerContent = null;
				}

			};
			servletWriter = new PrintWriter(out);
		}
	  return servletWriter;
	}

	public void setContentType(String contentType) {
		this.contentType = contentType;
		
	}

	/**
	 * @return Returns the contentType.
	 */
	public String getContentType() {
		return contentType;
	}
	
	private void writeObject(java.io.ObjectOutputStream s) throws IOException {
		if(filledOutputStream) {
			if(outputStream != null) {
				content = outputStream.toByteArray();
			}
		} else if(filledOutputWriter) {
			if(stringOutputWriter != null) {
				char[] cs = stringOutputWriter.toCharArray();
				writerContent = new String(cs);
			}
		}
		s.defaultWriteObject();
	}
}