cmsflexresponse.java

内容管理

    }
    
    /**
     * Helper method to add a value in the internal header list.<p>
     *
     * @param headers the headers to look up the value in
     * @param name the name to look up
     * @param value the value to set
     */
    private void addHeaderList(Map headers, String name, String value) {
        ArrayList values = (ArrayList) headers.get(name);
        if (values == null) {
            values = new ArrayList();
            headers.put(name, values);            
        } 
        values.add(value);        
    }
   
    /**
     * Helper method to set a value in the internal header list.
     *
     * @param headers the headers to set the value in
     * @param name the name to set
     * @param value the value to set
     */
    private void setHeaderList(Map headers, String name, String value) {
        ArrayList values = new ArrayList();
        values.add(C_SETHEADER + value);
        headers.put(name, values);        
    }
    
    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.ServletResponse#getWriter()
     */
    public java.io.PrintWriter getWriter() throws IOException {
        if (m_writer == null) initStream();
        return m_writer;
    }
    
    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.ServletResponse#getOutputStream()
     */
    public javax.servlet.ServletOutputStream getOutputStream() throws IOException {
        if (m_out == null) initStream();
        return m_out;
    }

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#sendRedirect(java.lang.String)
     */
    public void sendRedirect(String location) throws IOException {
        // Ignore any redirects after the first one
        if (isSuspended() && (! location.equals(m_buffer_redirect))) return;
        if (DEBUG) System.err.println("FlexResponse: sendRedirect to target " + location);
                
        if (m_cachingRequired && ! m_includeMode) {
            m_buffer_redirect = location;
        }
        
        if (! m_cachingRequired) {
            // If caching is required a cached entry will be constructed first and redirect will
            // be called after this is completed and stored in the cache
            if (DEBUG) System.err.println("FlexResponse: getTopResponse.sendRedirect() to target " + location);
            
            m_controller.getTopResponse().sendRedirect(location);        
        }
        
        m_controller.suspendFlexResponse();
    }
    
    /**
     * Process the headers stored in the provided map and add them to the response.<p>
     * 
     * @param headers the headers to add
     * @param res the resonse to add the headers to
     */
    public static void processHeaders(Map headers, HttpServletResponse res) {
        if (headers != null) {
            java.util.Iterator i = headers.keySet().iterator();
            while (i.hasNext()) {
                String key = (String)i.next();
                ArrayList l = (ArrayList)headers.get(key);  
                java.util.ListIterator j = l.listIterator(); 
                while (j.hasNext()) {
                    if ((j.nextIndex() == 0) && (((String)l.get(0)).startsWith(C_SETHEADER)))  {
                        String s = (String)j.next();
                        res.setHeader(key, s.substring(C_SETHEADER.length()));
                    } else {
                        res.addHeader(key, (String)j.next());
                    }
                }
            }        
        }          
    }
    
    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#setHeader(java.lang.String, java.lang.String)
     */
    public void setHeader(String name, String value) {
        if (isSuspended()) return;

        if (m_cachingRequired && ! m_includeMode) {
            setHeaderList(m_buffer_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") in element buffer");
        }
        
        if (m_writeOnlyToBuffer) {
            setHeaderList(m_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") in main header buffer");
        } else {
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") passing to parent");
            m_res.setHeader(name, value);
        }
    }

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#addHeader(java.lang.String, java.lang.String)
     */   
    public void addHeader(String name, String value) {
        if (isSuspended()) return;

        if (m_cachingRequired && ! m_includeMode) {
            addHeaderList(m_buffer_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") to element buffer");
        }
        
        if (m_writeOnlyToBuffer) {
            addHeaderList(m_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") to main header buffer");
        } else {
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") passing to parent");
            m_res.addHeader(name, value);
        }
    }
    
    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#setDateHeader(java.lang.String, long)
     */
    public void setDateHeader(String name, long date) {
        java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", java.util.Locale.US);
        setHeader(name, format.format(new java.util.Date(date)));
    }

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#addDateHeader(java.lang.String, long)
     */
    public void addDateHeader(String name, long date) {
        java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", java.util.Locale.US);
        addHeader(name, format.format(new java.util.Date(date)));
    }

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#setIntHeader(java.lang.String, int)
     */   
    public void setIntHeader(String name, int value) {
        setHeader(name, "" + value);       
    }

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.http.HttpServletResponse#addIntHeader(java.lang.String, int)
     */    
    public void addIntHeader(String name, int value) {
        addHeader(name, "" + value);
    }    

    /**
     * Method overlodad from the standard HttpServletRequest API.<p>
     *
     * @see javax.servlet.ServletResponse#setContentType(java.lang.String)
     */
    public void setContentType(String type) {
        if (DEBUG) System.err.println("FlexResponse: setContentType(" +type + ") called");
        // TODO: Check setContentType() implementation
        // If this is not the "Top-Level" element ignore all settings of content type    
        // If this is not done an included JSP could reset the type with some unwanted defaults    
        if (! m_isTopElement) return;
        /*       
        if (type != null) {
            // ensure that the encoding set by OpenCms is not overwritten by the default form the JSP            
            type = type.toLowerCase();
            int i = type.indexOf("charset");
            if (type.startsWith("text") && (i > 0)) {
                StringBuffer buf = new StringBuffer();
                buf.append(type.substring(0, i));
                buf.append("charset=");
                buf.append(m_encoding);
                type = new String(buf);
                if (DEBUG) System.err.println("FlexResponse: setContentType() changed type to " +type);
            }            
        }
        m_res.setContentType(type);
        */        
    }
    
    /**
     * Wrapped implementation of the ServletOutputStream.<p>
     * 
     * This implementation writes to an internal buffer and optionally to another 
     * output stream at the same time.
     * It should be fully transparent to the standard ServletOutputStream.<p>
     */    
    private class CmsServletOutputStream extends ServletOutputStream {

        /** The internal steam buffer */
        private java.io.ByteArrayOutputStream stream = null;
        
        /** The optional output stream to write to */
        private javax.servlet.ServletOutputStream servletStream = null;
        
        /** Debug flag */
        private static final boolean DEBUG = false;

        /**
         * Constructor that must be used if the stream should write 
         * only to a buffer.<p>
         */
        public CmsServletOutputStream() {
            this.servletStream = null;
            clear();
        }   

        /**
         * Constructor that must be used if the stream should write 
         * to a buffer and to another stream at the same time.<p>
         *
         * @param servletStream The stream to write to
         */        
        public CmsServletOutputStream(ServletOutputStream servletStream) {
            this.servletStream = servletStream;
            clear();                  
        }   
                
        /**
         * @see java.io.OutputStream#write(int)
         */
        public void write(int b) throws IOException {
            stream.write(b);
            if (servletStream != null) servletStream.write(b);
        }
        
        /**
         * @see java.io.OutputStream#write(byte[], int, int)
         */
        public void write(byte[] b, int off, int len) throws IOException {
            stream.write(b, off, len);
            if (servletStream != null) servletStream.write(b, off, len);
        }
        
        /**
         * Writes an array of bytes only to the included servlet stream,
         * not to the buffer.<p>
         *
         * @param b The bytes to write to the stream
         * @throws IOException In case the write() operation on the included servlet stream raises one
         */
        public void writeToServletStream(byte[] b) throws IOException {
            if (servletStream != null) servletStream.write(b);
        }
        
        /**
         * @see java.io.OutputStream#flush()
         */
        public void flush() throws IOException {
            if (DEBUG) System.err.println("CmsServletOutputStream: flush() called! servletStream=" + servletStream);
            if (servletStream != null) servletStream.flush();
        }
                
        /**
         * Provides access to the bytes cached in the buffer.<p>
         *
         * @return the cached bytes from the buffer
         */
        public byte[] getBytes() {
            return stream.toByteArray();
        }
        
        /**
         * Clears the buffer by initializing the buffer with a new stream.<p>
         */
        public void clear() {
            stream = new java.io.ByteArrayOutputStream(1024);
        }        
    }    
    
}