public CoyoteResponse() 
{
        format.setTimeZone(TimeZone.getTimeZone("GMT"));
        urlEncoder.addSafeCharacter('/");
}

 public  void addCookie(Cookie cookie) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        cookies.add(cookie);
        StringBuffer sb = new StringBuffer();
        ServerCookie.appendCookieValue
            (sb, cookie.getVersion(), cookie.getName(), cookie.getValue(),
             cookie.getPath(), cookie.getDomain(), cookie.getComment(), 
             cookie.getMaxAge(), cookie.getSecure());
        // the header name is Set-Cookie for both "old" and v.1 ( RFC2109 )
        // RFC2965 is not supported by browsers and the Servlet spec
        // asks for 2109.
        addHeader("Set-Cookie", sb.toString());
}

Add the specified Cookie to those that will be included with this Response.

 public  void addDateHeader(String name,
    long value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        addHeader(name, format.format(new Date(value)));
}

Add the specified date header to the specified value.

 public  void addHeader(String name,
    String value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.addHeader(name, value);
}

Add the specified header to the specified value.

 public  void addIntHeader(String name,
    int value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        addHeader(name, "" + value);
}

Add the specified integer header to the specified value.

 public boolean containsHeader(String name) 
{
        return coyoteResponse.containsHeader(name);
}

Has the specified header been set already in this response?

 public ServletOutputStream createOutputStream() throws IOException 
{
        // Probably useless
        return outputStream;
}

Create and return a ServletOutputStream to write the content associated with this Response.

 public String encodeRedirectURL(String url) 
{
        if (isEncodeable(toAbsolute(url))) {
            HttpServletRequest hreq =
                (HttpServletRequest) request.getRequest();
            return (toEncoded(url, hreq.getSession().getId()));
        } else {
            return (url);
        }
}

Encode the session identifier associated with this response into the specified redirect URL, if necessary.

 public String encodeRedirectUrl(String url) 
{
        return (encodeRedirectURL(url));
}

Encode the session identifier associated with this response into the specified redirect URL, if necessary.

 public String encodeURL(String url) 
{
        
        String absolute = toAbsolute(url);
        if (isEncodeable(absolute)) {
            HttpServletRequest hreq =
                (HttpServletRequest) request.getRequest();
            // W3c spec clearly said 
            if (url.equalsIgnoreCase("")){
                url = absolute;
            }
            return (toEncoded(url, hreq.getSession().getId()));
        } else {
            return (url);
        }
}

Encode the session identifier associated with this response into the specified URL, if necessary.

 public String encodeUrl(String url) 
{
        return (encodeURL(url));
}

Encode the session identifier associated with this response into the specified URL, if necessary.

 public  void finishResponse() throws IOException 
{
        // Writing leftover bytes
        try {
            outputBuffer.close();
        } catch(IOException e) {
            ;
        } catch(Throwable t) {
            t.printStackTrace();
        }
}

Perform whatever actions are required to flush and close the output stream or writer, in a single operation.

 public  void flushBuffer() throws IOException 
{
        outputBuffer.flush();
}

Flush the buffer and commit this response.

 public int getBufferSize() 
{
        return outputBuffer.getBufferSize();
}

Return the actual buffer size used for this Response.

 public String getCharacterEncoding() 
{
        return (coyoteResponse.getCharacterEncoding());
}

Return the character encoding used for this Response.

 public Connector getConnector() 
{
                  
        return (this.connector);
}

Return the Connector through which this Request was received.

 public int getContentCount() 
{
        return outputBuffer.getContentWritten();
}

Return the number of bytes actually written to the output stream.

 public int getContentLength() 
{
        return (coyoteResponse.getContentLength());
}

Return the content length that was set or calculated for this Response.

 public String getContentType() 
{
        return (coyoteResponse.getContentType());
}

Return the content type that was set or calculated for this response, or null if no content type was set.

 public Context getContext() 
{
                   
        return (this.context);
}

Return the Context within which this Request is being processed.

 public Cookie[] getCookies() 
{
        return ((Cookie[]) cookies.toArray(new Cookie[cookies.size()]));
}

Return an array of all cookies set for this response, or a zero-length array if no cookies have been set.

 public Response getCoyoteResponse() 
{
        return (coyoteResponse);
}

Get the Coyote response.

 public String getHeader(String name) 
{
        return coyoteResponse.getMimeHeaders().getHeader(name);
}

Return the value for the specified header, or null if this header has not been set. If more than one value was added for this name, only the first is returned; use getHeaderValues() to retrieve all of them.

 public String[] getHeaderNames() 
{
        MimeHeaders headers = coyoteResponse.getMimeHeaders();
        int n = headers.size();
        String[] result = new String[n];
        for (int i = 0; i <  n; i++) {
            result[i] = headers.getName(i).toString();
        }
        return result;
}

Return an array of all the header names set for this response, or a zero-length array if no headers have been set.

 public String[] getHeaderValues(String name) 
{
        Enumeration headerValues = coyoteResponse.getMimeHeaders().values(name);
        Vector result = new Vector();
        while (headerValues.hasMoreElements()) {
            result.addElement(headerValues.nextElement());
        }
        String[] resultArray = new String[result.size()];
        result.copyInto(resultArray);
        return resultArray;
}

Return an array of all the header values associated with the specified header name, or an zero-length array if there are no such header values.

 public boolean getIncluded() 
{
        return included;
}

Return the "processing inside an include" flag.

 public String getInfo() 
{
        return (info);
}

Return descriptive information about this Response implementation and the corresponding version number, in the format <description>/<version>.

 public Locale getLocale() 
{
        return (coyoteResponse.getLocale());
}

Return the Locale assigned to this response.

 public String getMessage() 
{
        return coyoteResponse.getMessage();
}

Return the error message that was set with sendError() for this Response.

 public ServletOutputStream getOutputStream() throws IOException 
{
        if (usingWriter)
            throw new IllegalStateException
                (sm.getString("coyoteResponse.getOutputStream.ise"));
        usingOutputStream = true;
        return outputStream;
}

Return the servlet output stream associated with this Response.

 public PrintWriter getReporter() 
{
        if (outputBuffer.isNew()) {
            return writer;
        } else {
            return null;
        }
}

Return a PrintWriter that can be used to render error messages, regardless of whether a stream or writer has already been acquired.

 public Request getRequest() 
{
                  
        return (this.request);
}

Return the Request with which this Response is associated.

 public ServletResponse getResponse() 
{
                   
        if (facade == null) {
            facade = new CoyoteResponseFacade(this);
        }
        return (facade);
}

Return the ServletResponse for which this object is the facade.

 public int getStatus() 
{
        return coyoteResponse.getStatus();
}

Return the HTTP status code associated with this Response.

 public OutputStream getStream() 
{
        return outputStream;
}

Return the output stream associated with this Response.

 public PrintWriter getWriter() throws IOException 
{
        if (usingOutputStream)
            throw new IllegalStateException
                (sm.getString("coyoteResponse.getWriter.ise"));
        usingWriter = true;
        return writer;
}

Return the writer associated with this Response.

 public boolean isAppCommitted() 
{
        return (this.appCommitted || isCommitted() || isSuspended());
}

Application commit flag accessor.

 public boolean isCommitted() 
{
        return (coyoteResponse.isCommitted());
}

Has the output of this response already been committed?

 protected boolean isEncodeable(String location) 
{
        if (location == null)
            return (false);
        // Is this an intra-document reference?
        if (location.startsWith("#"))
            return (false);
        // Are we in a valid session that is not using cookies?
        HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
        HttpSession session = hreq.getSession(false);
        if (session == null)
            return (false);
        if (hreq.isRequestedSessionIdFromCookie())
            return (false);
        // Is this a valid absolute URL?
        URL url = null;
        try {
            url = new URL(location);
        } catch (MalformedURLException e) {
            return (false);
        }
        // Does this URL match down to (and including) the context path?
        if (!hreq.getScheme().equalsIgnoreCase(url.getProtocol()))
            return (false);
        if (!hreq.getServerName().equalsIgnoreCase(url.getHost()))
            return (false);
        int serverPort = hreq.getServerPort();
        if (serverPort == -1) {
            if ("https".equals(hreq.getScheme()))
                serverPort = 443;
            else
                serverPort = 80;
        }
        int urlPort = url.getPort();
        if (urlPort == -1) {
            if ("https".equals(url.getProtocol()))
                urlPort = 443;
            else
                urlPort = 80;
        }
        if (serverPort != urlPort)
            return (false);
        String contextPath = getContext().getPath();
        if (contextPath != null) {
            String file = url.getFile();
            if ((file == null) || !file.startsWith(contextPath))
                return (false);
            if( file.indexOf(";jsessionid=" + session.getId())  >= 0 )
                return (false);
        }
        // This URL belongs to our web application, so it is encodeable
        return (true);
}

Return true if the specified URL should be encoded with a session identifier. This will be true if all of the following conditions are met:
• The request we are responding to asked for a valid session
• The requested session ID was not received via a cookie
• The specified URL points back to somewhere within the web application that is responding to this request

 public boolean isError() 
{
        return error;
}

Error flag accessor.

 public boolean isSuspended() 
{
        return outputBuffer.isSuspended();
}

Suspended flag accessor.

 public  void recycle() 
{
    // --------------------------------------------------------- Public Methods
        outputBuffer.recycle();
        usingOutputStream = false;
        usingWriter = false;
        appCommitted = false;
        included = false;
        error = false;
        cookies.clear();
        if (facade != null) {
            facade.clear();
            facade = null;
        }
        writer.recycle();
}

Release all object references, and initialize instance variables, in preparation for reuse of this object.

 public  void reset() 
{
        if (included)
            return;     // Ignore any call from an included servlet
        coyoteResponse.reset();
        outputBuffer.reset();
}

Clear any content written to the buffer.

 public  void reset(int status,
    String message) 
{
        reset();
        setStatus(status, message);
}

Reset this response, and specify the values for the HTTP status code and corresponding message.

 public  void resetBuffer() 
{
        if (isCommitted())
            throw new IllegalStateException
                (sm.getString("coyoteResponse.resetBuffer.ise"));
        outputBuffer.reset();
}

Reset the data buffer but not any status or header information.

 public  void sendAcknowledgement() throws IOException 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return; 
        coyoteResponse.acknowledge();
}

Send an acknowledgment of a request.

 public  void sendError(int status) throws IOException 
{
        sendError(status, null);
}

Send an error response with the specified status and a default message.

 public  void sendError(int status,
    String message) throws IOException 
{
        if (isCommitted())
            throw new IllegalStateException
                (sm.getString("coyoteResponse.sendError.ise"));
        // Ignore any call from an included servlet
        if (included)
            return; 
        setError();
        coyoteResponse.setStatus(status);
        coyoteResponse.setMessage(message);
        // Clear any data content that has been buffered
        resetBuffer();
        // Cause the response to be finished (from the application perspective)
        setSuspended(true);
}

Send an error response with the specified status and message.

 public  void sendRedirect(String location) throws IOException 
{
        if (isCommitted())
            throw new IllegalStateException
                (sm.getString("coyoteResponse.sendRedirect.ise"));
        // Ignore any call from an included servlet
        if (included)
            return; 
        // Clear any data content that has been buffered
        resetBuffer();
        // Generate a temporary redirect to the specified location
        try {
            String absolute = toAbsolute(location);
            setStatus(SC_MOVED_TEMPORARILY);
            setHeader("Location", absolute);
        } catch (IllegalArgumentException e) {
            setStatus(SC_NOT_FOUND);
        }
        // Cause the response to be finished (from the application perspective)
        setSuspended(true);
}

Send a temporary redirect to the specified redirect location URL.

 public  void setAppCommitted(boolean appCommitted) 
{
        this.appCommitted = appCommitted;
}

Set the application commit flag.

 public  void setBufferSize(int size) 
{
        if (isCommitted() || !outputBuffer.isNew())
            throw new IllegalStateException
                (sm.getString("coyoteResponse.setBufferSize.ise"));
        outputBuffer.setBufferSize(size);
}

Set the buffer size to be used for this Response.

 public  void setConnector(Connector connector) 
{
        this.connector = connector;
}

Set the Connector through which this Request was received.

 public  void setContentLength(int length) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.setContentLength(length);
}

Set the content length (in bytes) for this Response.

 public  void setContentType(String type) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.setContentType(type);
}

Set the content type for this Response.

 public  void setContext(Context context) 
{
        this.context = context;
}

Set the Context within which this Request is being processed. This must be called as soon as the appropriate Context is identified, because it identifies the value to be returned by getContextPath(), and thus enables parsing of the request URI.

 public  void setCoyoteResponse(Response coyoteResponse) 
{
        this.coyoteResponse = coyoteResponse;
        outputBuffer.setResponse(coyoteResponse);
}

Set the Coyote response.

 public  void setDateHeader(String name,
    long value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        setHeader(name, format.format(new Date(value)));
}

Set the specified date header to the specified value.

 public  void setError() 
{
        error = true;
}

Set the error flag.

 public  void setHeader(String name,
    String value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.setHeader(name, value);
}

Set the specified header to the specified value.

 public  void setIncluded(boolean included) 
{
        this.included = included;
}

Set the "processing inside an include" flag.

 public  void setIntHeader(String name,
    int value) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        setHeader(name, "" + value);
}

Set the specified integer header to the specified value.

 public  void setLocale(Locale locale) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.setLocale(locale);
        // Set the specified locale's default encoding of a response
        CharsetMapper cm = context.getCharsetMapper();
        String charset = cm.getCharset(locale);
        if (charset != null) {
            coyoteResponse.setCharacterEncoding(charset);
        }
}

Set the Locale that is appropriate for this response, including setting the appropriate character encoding.

 public  void setRequest(Request request) 
{
        this.request = (CoyoteRequest) request;
}

Set the Request with which this Response is associated.

 public  void setStatus(int status) 
{
        setStatus(status, null);
}

Set the HTTP status to be returned with this response.

 public  void setStatus(int status,
    String message) 
{
        if (isCommitted())
            return;
        // Ignore any call from an included servlet
        if (included)
            return;
        coyoteResponse.setStatus(status);
        coyoteResponse.setMessage(message);
}

Set the HTTP status and message to be returned with this response.

 public  void setStream(OutputStream stream) 
{
        // This method is evil
}

Set the output stream associated with this Response.

 public  void setSuspended(boolean suspended) 
{
        outputBuffer.setSuspended(suspended);
}

Set the suspended flag.