package org.apache.turbine.services.rundata;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * 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.
   */
  
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  
  import javax.naming.Context;
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.ecs.Document;
  import org.apache.ecs.Element;
  import org.apache.ecs.StringElement;
  import org.apache.fulcrum.mimetype.MimeTypeService;
  import org.apache.fulcrum.parser.CookieParser;
  import org.apache.fulcrum.parser.ParameterParser;
  import org.apache.fulcrum.pool.Recyclable;
  import org.apache.fulcrum.security.acl.AccessControlList;
  import org.apache.turbine.Turbine;
  import org.apache.turbine.TurbineConstants;
  import org.apache.turbine.om.security.User;
  import org.apache.turbine.pipeline.DefaultPipelineData;
  import org.apache.turbine.services.ServiceManager;
  import org.apache.turbine.services.TurbineServices;
  import org.apache.turbine.services.template.TurbineTemplate;
  import org.apache.turbine.util.FormMessages;
  import org.apache.turbine.util.ServerData;
  import org.apache.turbine.util.SystemError;
  import org.apache.turbine.util.template.TemplateInfo;
  
  /**
   * DefaultTurbineRunData is the default implementation of the
   * TurbineRunData interface, which is distributed by the Turbine
   * RunData service, if another implementation is not defined in
   * the default or specified RunData configuration.
   * TurbineRunData is an extension to RunData, which
   * is an interface to run-rime information that is passed
   * within Turbine. This provides the threading mechanism for the
   * entire system because multiple requests can potentially come in
   * at the same time.  Thus, there is only one RunData implementation
   * for each request that is being serviced.
   *
   * <p>DefaultTurbineRunData implements the Recyclable interface making
   * it possible to pool its instances for recycling.
   *
   * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
   * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
   * @author <a href="mailto:bhoeneis@ee.ethz.ch">Bernie Hoeneisen</a>
   * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
   * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
   * @version $Id: DefaultTurbineRunData.java 1706239 2015-10-01 13:18:35Z tv $
   */
  public class DefaultTurbineRunData
          extends DefaultPipelineData
          implements TurbineRunData, Recyclable
  {
      /**
       * The disposed flag.
       */
      private boolean disposed;
  
      /** The default locale. */
      private static Locale defaultLocale = null;
  
      /** The default charset. */
      private static String defaultCharSet = null;
  
      /** Determines if there is information in the document or not. */
      private boolean pageSet;
 
     /** This creates an ECS Document. */
     private Document page;
 
     /** Cached action name to execute for this request. */
     private String action;
 
     /** This is the layout that the page will use to render the screen. */
     private String layout;
 
     /** Cached screen name to execute for this request. */
     private String screen;
 
     /** The character encoding of template files. */
     private String templateEncoding;
 
     /** This is what will build the <title></title> of the document. */
     private String title;
 
     /** Determines if there is information in the outputstream or not. */
     private boolean outSet;
 
     /**
      * Cache the output stream because it can be used in many
      * different places.
      */
     private PrintWriter out;
 
     /** The HTTP charset. */
     private String charSet;
 
     /** The HTTP content type to return. */
     private String contentType = "text/html";
 
     /** If this is set, also set the status code to 302. */
     private String redirectURI;
 
     /** The HTTP status code to return. */
     private int statusCode = HttpServletResponse.SC_OK;
 
     /** This is a List to hold critical system errors. */
     private final List<SystemError> errors = new ArrayList<SystemError>();
 
     /** JNDI Contexts. */
     private Map<String, Context> jndiContexts;
 
     /** @see #getRemoteAddr() */
     private String remoteAddr;
 
     /** @see #getRemoteHost() */
     private String remoteHost;
 
     /** @see #getUserAgent() */
     private String userAgent;
 
     /** A holder for stack trace. */
     private String stackTrace;
 
     /** A holder for stack trace exception. */
     private Throwable stackTraceException;
 
     /**
      * Put things here and they will be shown on the default Error
      * screen.  This is great for debugging variable values when an
      * exception is thrown.
      */
     private final Map<String, Object> debugVariables = new HashMap<String, Object>();
 
     /** Logging */
     private static Log log = LogFactory.getLog(DefaultTurbineRunData.class);
 
     /**
      * Attempts to get the User object from the session.  If it does
      * not exist, it returns null.
      *
      * @param session An HttpSession.
      * @return A User.
      */
     public static <T extends User> T getUserFromSession(HttpSession session)
     {
         try
         {
             @SuppressWarnings("unchecked")
             T user = (T) session.getAttribute(User.SESSION_KEY);
             return user;
         }
         catch (ClassCastException e)
         {
             return null;
         }
     }
 
     /**
      * Allows one to invalidate the user in a session.
      *
      * @param session An HttpSession.
      * @return True if user was invalidated.
      */
     public static boolean removeUserFromSession(HttpSession session)
     {
         try
         {
             session.removeAttribute(User.SESSION_KEY);
         }
         catch (Exception e)
         {
             return false;
         }
         return true;
     }
 
     /**
      * Gets the default locale defined by properties named
      * "locale.default.lang" and "locale.default.country".
      *
      * This changed from earlier Turbine versions that you can
      * rely on getDefaultLocale() to never return null.
      *
      * @return A Locale object.
      */
     protected static Locale getDefaultLocale()
     {
         if (defaultLocale == null)
         {
             /* Get the default locale and cache it in a static variable. */
             String lang = Turbine.getConfiguration()
                 .getString(TurbineConstants.LOCALE_DEFAULT_LANGUAGE_KEY,
                     TurbineConstants.LOCALE_DEFAULT_LANGUAGE_DEFAULT);
 
             String country = Turbine.getConfiguration()
                 .getString(TurbineConstants.LOCALE_DEFAULT_COUNTRY_KEY,
                     TurbineConstants.LOCALE_DEFAULT_COUNTRY_DEFAULT);
 
 
             // We ensure that lang and country is never null
             defaultLocale =  new Locale(lang, country);
         }
         return defaultLocale;
     }
 
     /**
      * Gets the default charset defined by a property named
      * "locale.default.charset" or by the specified locale.
      * If the specified locale is null, the default locale is applied.
      *
      * @return the name of the default charset or null.
      */
     protected String getDefaultCharSet()
     {
         log.debug("getDefaultCharSet()");
 
         if (defaultCharSet == null)
         {
             /* Get the default charset and cache it in a static variable. */
             defaultCharSet = Turbine.getConfiguration()
                 .getString(TurbineConstants.LOCALE_DEFAULT_CHARSET_KEY,
                     TurbineConstants.LOCALE_DEFAULT_CHARSET_DEFAULT);
             log.debug("defaultCharSet = " + defaultCharSet + " (From Properties)");
         }
 
         String charset = defaultCharSet;
 
         if (StringUtils.isEmpty(charset))
         {
             log.debug("charset is empty!");
             /* Default charset isn't specified, get the locale specific one. */
             Locale locale = getLocale();
             if (locale == null)
             {
                 locale = getDefaultLocale();
                 log.debug("Locale was null, is now " + locale + " (from getDefaultLocale())");
             }
 
             log.debug("Locale is " + locale);
 
             if (!locale.equals(Locale.US))
             {
                 log.debug("We don't have US Locale!");
                 ServiceManager serviceManager = TurbineServices.getInstance();
 				MimeTypeService mimeTypeService=null;
                 try {
 					mimeTypeService= (MimeTypeService)serviceManager.getService(MimeTypeService.ROLE);
                 }
                 catch (Exception e){
                     throw new RuntimeException(e);
                 }
                 charset = mimeTypeService.getCharSet(locale);
 
                 log.debug("Charset now " + charset);
             }
         }
 
         log.debug("Returning default Charset of " + charset);
         return charset;
     }
 
     /**
      * Constructs a run data object.
      */
     public DefaultTurbineRunData()
     {
         super();
 
         // a map to hold information to be added to pipelineData
         put(Turbine.class, new HashMap<Class<?>, Object>());
         recycle();
     }
 
     /**
      * Recycles the object by removing its disposed flag.
      */
     @Override
     public void recycle()
     {
         disposed = false;
     }
 
     /**
      * Disposes a run data object.
      */
     @Override
     public void dispose()
     {
         // empty pipelinedata map
         get(Turbine.class).clear();
 
         pageSet = false;
         page = null;
         action = null;
         layout = null;
         screen = null;
         templateEncoding = null;
         title = null;
         outSet = false;
         out = null;
         charSet = null;
         contentType = "text/html";
         redirectURI = null;
         statusCode = HttpServletResponse.SC_OK;
         errors.clear();
         jndiContexts = null;
         remoteAddr = null;
         remoteHost = null;
         userAgent = null;
         stackTrace = null;
         stackTraceException = null;
         debugVariables.clear();
     }
 
     // ***************************************
     // Implementation of the RunData interface
     // ***************************************
 
     /**
      * Gets the parameters.
      *
      * @return a parameter parser.
      */
     @Override
     public ParameterParser getParameters()
     {
         // Parse the parameters first, if not yet done.
         ParameterParser parameters = getParameterParser();
         HttpServletRequest request = getRequest();
 
         if ((parameters != null) &&
                 (parameters.getRequest() != request))
         {
             parameters.setRequest(request);
         }
 
         return parameters;
     }
 
     /**
      * Gets the cookies.
      *
      * @return a cookie parser.
      */
     @Override
     public CookieParser getCookies()
     {
         // Parse the cookies first, if not yet done.
         CookieParser cookies = getCookieParser();
         HttpServletRequest request = getRequest();
 
         if ((cookies != null) &&
                 (cookies.getRequest() != request))
         {
             cookies.setData(request, getResponse());
         }
 
         return cookies;
     }
 
     /**
      * Gets the servlet request.
      *
      * @return the request.
      */
     @Override
     public HttpServletRequest getRequest()
     {
         return get(Turbine.class, HttpServletRequest.class);
     }
 
     /**
      * Gets the servlet response.
      *
      * @return the response.
      */
     @Override
     public HttpServletResponse getResponse()
     {
         return get(Turbine.class, HttpServletResponse.class);
     }
 
     /**
      * Gets the servlet session information.
      *
      * @return the session.
      */
     @Override
     public HttpSession getSession()
     {
         return getRequest().getSession();
     }
 
     /**
      * Gets the servlet configuration used during servlet init.
      *
      * @return the configuration.
      */
     @Override
     public ServletConfig getServletConfig()
     {
         return get(Turbine.class, ServletConfig.class);
     }
 
     /**
      * Gets the servlet context used during servlet init.
      *
      * @return the context.
      */
     @Override
     public ServletContext getServletContext()
     {
         return get(Turbine.class, ServletContext.class);
     }
 
     /**
      * Gets the access control list.
      *
      * @return the access control list.
      */
     @Override
     public <A extends AccessControlList> A getACL()
     {
         @SuppressWarnings("unchecked")
         A acl = (A)get(Turbine.class, AccessControlList.class);
         return acl;
     }
 
     /**
      * Sets the access control list.
      *
      * @param acl an access control list.
      */
     @Override
     public void setACL(AccessControlList acl)
     {
         get(Turbine.class).put(AccessControlList.class, acl);
     }
 
     /**
      * Checks to see if the page is set.
      *
      * @return true if the page is set.
      * @deprecated no replacement planned, ECS is no longer a requirement
      */
     @Override
     @Deprecated
     public boolean isPageSet()
     {
         return pageSet;
     }
 
     /**
      * Gets the page.
      *
      * @return a document.
      * @deprecated no replacement planned, ECS is no longer a requirement
      */
     @Override
     @Deprecated
     public Document getPage()
     {
         pageSet = true;
         if (this.page == null)
         {
             this.page = new Document();
         }
         return this.page;
     }
 
     /**
      * Whether or not an action has been defined.
      *
      * @return true if an action has been defined.
      */
     @Override
     public boolean hasAction()
     {
         return (StringUtils.isNotEmpty(this.action)
           && !this.action.equalsIgnoreCase("null"));
     }
 
     /**
      * Gets the action. It returns an empty string if null so
      * that it is easy to do conditionals on it based on the
      * equalsIgnoreCase() method.
      *
      * @return a string, "" if null.
      */
     @Override
     public String getAction()
     {
         return (hasAction() ? this.action : "");
     }
 
     /**
      * Sets the action for the request.
      *
      * @param action a atring.
      */
     @Override
     public void setAction(String action)
     {
         this.action = action;
     }
 
     /**
      * If the Layout has not been defined by the screen then set the
      * layout to be "DefaultLayout".  The screen object can also
      * override this method to provide intelligent determination of
      * the Layout to execute.  You can also define that logic here as
      * well if you want it to apply on a global scale.  For example,
      * if you wanted to allow someone to define layout "preferences"
      * where they could dynamically change the layout for the entire
      * site.
      *
      * @return a string.
      */
 
     @Override
     public String getLayout()
     {
         if (this.layout == null)
         {
             /*
              * This will return something if the template
              * services are running. If we get nothing we
              * will fall back to the ECS layout.
              */
             layout = TurbineTemplate.getDefaultLayoutName(this);
 
             if (layout == null)
             {
                 layout = "DefaultLayout";
             }
         }
 
         return this.layout;
     }
 
     /**
      * Set the layout for the request.
      *
      * @param layout a string.
      */
     @Override
     public void setLayout(String layout)
     {
         this.layout = layout;
     }
 
     /**
      * Convenience method for a template info that
      * returns the layout template being used.
      *
      * @return a string.
      */
     @Override
     public String getLayoutTemplate()
     {
         return getTemplateInfo().getLayoutTemplate();
     }
 
     /**
      * Modifies the layout template for the screen. This convenience
      * method allows for a layout to be modified from within a
      * template. For example;
      *
      *    $data.setLayoutTemplate("NewLayout.vm")
      *
      * @param layout a layout template.
      */
     @Override
     public void setLayoutTemplate(String layout)
     {
         getTemplateInfo().setLayoutTemplate(layout);
     }
 
     /**
      * Whether or not a screen has been defined.
      *
      * @return true if a screen has been defined.
      */
     @Override
     public boolean hasScreen()
     {
         return StringUtils.isNotEmpty(this.screen);
     }
 
     /**
      * Gets the screen to execute.
      *
      * @return a string.
      */
     @Override
     public String getScreen()
     {
         return (hasScreen() ? this.screen : "");
     }
 
     /**
      * Sets the screen for the request.
      *
      * @param screen a string.
      */
     @Override
     public void setScreen(String screen)
     {
         this.screen = screen;
     }
 
     /**
      * Convenience method for a template info that
      * returns the name of the template being used.
      *
      * @return a string.
      */
     @Override
     public String getScreenTemplate()
     {
         return getTemplateInfo().getScreenTemplate();
     }
 
     /**
      * Sets the screen template for the request. For
      * example;
      *
      *    $data.setScreenTemplate("NewScreen.vm")
      *
      * @param screen a screen template.
      */
     @Override
     public void setScreenTemplate(String screen)
     {
         getTemplateInfo().setScreenTemplate(screen);
     }
 
     /**
      * Gets the character encoding to use for reading template files.
      *
      * @return the template encoding or null if not specified.
      */
     @Override
     public String getTemplateEncoding()
     {
         return templateEncoding;
     }
 
     /**
      * Sets the character encoding to use for reading template files.
      *
      * @param encoding the template encoding.
      */
     @Override
     public void setTemplateEncoding(String encoding)
     {
         templateEncoding = encoding;
     }
 
     /**
      * Gets the template info. Creates a new one if needed.
      *
      * @return a template info.
      */
     @Override
     public TemplateInfo getTemplateInfo()
     {
         TemplateInfo templateInfo = get(Turbine.class, TemplateInfo.class);
 
         if (templateInfo == null)
         {
             templateInfo = new TemplateInfo(this);
             get(Turbine.class).put(TemplateInfo.class, templateInfo);
         }
 
         return templateInfo;
     }
 
     /**
      * Whether or not a message has been defined.
      *
      * @return true if a message has been defined.
      */
     @Override
     public boolean hasMessage()
     {
         StringElement message = get(Turbine.class, StringElement.class);
         return (message != null)
             && StringUtils.isNotEmpty(message.toString());
     }
 
     /**
      * Gets the results of an action or another message
      * to be displayed as a string.
      *
      * @return a string.
      */
     @Override
     public String getMessage()
     {
         StringElement message = get(Turbine.class, StringElement.class);
         return (message == null ? null : message.toString());
     }
 
     /**
      * Sets the message for the request as a string.
      *
      * @param msg a string.
      */
     @Override
     public void setMessage(String msg)
     {
         get(Turbine.class).put(StringElement.class, new StringElement(msg));
     }
 
     /**
      * Adds the string to message. If message has prior messages from
      * other actions or screens, this method can be used to chain them.
      *
      * @param msg a string.
      */
     @Override
     public void addMessage(String msg)
     {
         addMessage(new StringElement(msg));
     }
 
     /**
      * Gets the results of an action or another message
      * to be displayed as an ECS string element.
      *
      * @return a string element.
      */
     @Override
     public StringElement getMessageAsHTML()
     {
         return get(Turbine.class, StringElement.class);
     }
 
     /**
      * Sets the message for the request as an ECS element.
      *
      * @param msg an element.
      */
     @Override
     public void setMessage(Element msg)
     {
         get(Turbine.class).put(StringElement.class, new StringElement(msg));
     }
 
     /**
      * Adds the ECS element to message. If message has prior messages from
      * other actions or screens, this method can be used to chain them.
      *
      * @param msg an element.
      */
     @Override
     public void addMessage(Element msg)
     {
         if (msg != null)
         {
             StringElement message = get(Turbine.class, StringElement.class);
 
             if (message != null)
             {
                 message.addElement(msg);
             }
             else
             {
                 setMessage(msg);
             }
         }
     }
 
     /**
      * Unsets the message for the request.
      */
     @Override
     public void unsetMessage()
     {
         get(Turbine.class).remove(StringElement.class);
     }
 
     /**
      * Gets a FormMessages object where all the messages to the
      * user should be stored.
      *
      * @return a FormMessages.
      */
     @Override
     public FormMessages getMessages()
     {
         FormMessages messages = get(Turbine.class, FormMessages.class);
         if (messages == null)
         {
             messages = new FormMessages();
             setMessages(messages);
         }
 
         return messages;
     }
 
     /**
      * Sets the FormMessages object for the request.
      *
      * @param msgs A FormMessages.
      */
     @Override
     public void setMessages(FormMessages msgs)
     {
         get(Turbine.class).put(FormMessages.class, msgs);
     }
 
     /**
      * Gets the title of the page.
      *
      * @return a string.
      */
     @Override
     public String getTitle()
     {
         return (this.title == null ? "" : this.title);
     }
 
     /**
      * Sets the title of the page.
      *
      * @param title a string.
      */
     @Override
     public void setTitle(String title)
     {
         this.title = title;
     }
 
     /**
      * Checks if a user exists in this session.
      *
      * @return true if a user exists in this session.
      */
     @Override
     public boolean userExists()
     {
         User user = getUserFromSession();
 
         // TODO: Check if this side effect is reasonable
         get(Turbine.class).put(User.class, user);
 
         return (user != null);
     }
 
     /**
      * Gets the user.
      *
      * @return a user.
      */
     @Override
     public <T extends User> T getUser()
     {
         @SuppressWarnings("unchecked")
         T user = (T)get(Turbine.class, User.class);
         return user;
     }
 
     /**
      * Sets the user.
      *
      * @param user a user.
      */
     @Override
     public void setUser(User user)
     {
         log.debug("user set: " + user.getName());
         get(Turbine.class).put(User.class, user);
     }
 
     /**
      * Attempts to get the user from the session. If it does
      * not exist, it returns null.
      *
      * @return a user.
      */
     @Override
     public <T extends User> T getUserFromSession()
     {
         return getUserFromSession(getSession());
     }
 
     /**
      * Allows one to invalidate the user in the default session.
      *
      * @return true if user was invalidated.
      */
     @Override
     public boolean removeUserFromSession()
     {
         return removeUserFromSession(getSession());
     }
 
     /**
      * Checks to see if out is set.
      *
      * @return true if out is set.
      * @deprecated no replacement planned, response writer will not be cached
      */
     @Override
     @Deprecated
     public boolean isOutSet()
     {
         return outSet;
     }
 
     /**
      * Gets the print writer. First time calling this
      * will set the print writer via the response.
      *
      * @return a print writer.
      * @throws IOException
      */
     @Override
     public PrintWriter getOut()
             throws IOException
     {
         // Check to see if null first.
         if (this.out == null)
         {
             setOut(getResponse().getWriter());
         }
         pageSet = false;
         outSet = true;
         return this.out;
     }
 
     /**
      * Declares that output will be direct to the response stream,
      * even though getOut() may never be called.  Useful for response
      * mechanisms that may call res.getWriter() themselves
      * (such as JSP.)
      */
     @Override
     public void declareDirectResponse()
     {
         outSet = true;
         pageSet = false;
     }
 
     /**
      * Gets the locale. If it has not already been defined with
      * setLocale(), then  properties named "locale.default.lang"
      * and "locale.default.country" are checked from the Resource
      * Service and the corresponding locale is returned. If these
      * properties are undefined, JVM's default locale is returned.
      *
      * @return the locale.
      */
     @Override
     public Locale getLocale()
     {
         Locale locale = get(Turbine.class, Locale.class);
         if (locale == null)
         {
             locale = getDefaultLocale();
         }
         return locale;
     }
 
     /**
      * Sets the locale.
      *
      * @param locale the new locale.
      */
     @Override
     public void setLocale(Locale locale)
     {
         get(Turbine.class).put(Locale.class, locale);
 
         // propagate the locale to the parsers
         ParameterParser parameters = get(Turbine.class, ParameterParser.class);
         CookieParser cookies = get(Turbine.class, CookieParser.class);
 
         if (parameters != null)
         {
             parameters.setLocale(locale);
         }
 
         if (cookies != null)
         {
             cookies.setLocale(locale);
         }
     }
 
     /**
      * Gets the charset. If it has not already been defined with
      * setCharSet(), then a property named "locale.default.charset"
      * is checked from the Resource Service and returned. If this
      * property is undefined, the default charset of the locale
      * is returned. If the locale is undefined, null is returned.
      *
      * @return the name of the charset or null.
      */
     @Override
     public String getCharSet()
     {
         log.debug("getCharSet()");
 
         if (StringUtils.isEmpty(charSet))
         {
             log.debug("Charset was null!");
             return getDefaultCharSet();
         }
         else
         {
             return charSet;
         }
     }
 
     /**
      * Sets the charset.
      *
      * @param charSet the name of the new charset.
      */
     @Override
     public void setCharSet(String charSet)
     {
         log.debug("setCharSet(" + charSet + ")");
         this.charSet = charSet;
     }
 
     /**
      * Gets the HTTP content type to return. If a charset
      * has been specified, it is included in the content type.
      * If the charset has not been specified and the main type
      * of the content type is "text", the default charset is
      * included. If the default charset is undefined, but the
      * default locale is defined and it is not the US locale,
      * a locale specific charset is included.
      *
      * @return the content type or an empty string.
      */
     @Override
     public String getContentType()
     {
         if (StringUtils.isNotEmpty(contentType))
         {
             if (StringUtils.isEmpty(charSet))
             {
                 if (contentType.startsWith("text/"))
                 {
                     return contentType + "; charset=" + getDefaultCharSet();
                 }
 
                 return contentType;
             }
             else
             {
                 return contentType + "; charset=" + charSet;
             }
         }
 
         return "";
     }
 
     /**
      * Sets the HTTP content type to return.
      *
      * @param contentType a string.
      */
     @Override
     public void setContentType(String contentType)
     {
         this.contentType = contentType;
     }
 
     /**
      * Gets the redirect URI. If this is set, also make sure to set
      * the status code to 302.
      *
      * @return a string, "" if null.
      */
     @Override
     public String getRedirectURI()
     {
         return (this.redirectURI == null ? "" : redirectURI);
     }
 
     /**
      * Sets the redirect uri. If this is set, also make sure to set
      * the status code to 302.
      *
      * @param ruri a string.
      */
     @Override
     public void setRedirectURI(String ruri)
     {
         this.redirectURI = ruri;
     }
 
     /**
      * Gets the HTTP status code to return.
      *
      * @return the status.
      */
     @Override
     public int getStatusCode()
     {
         return statusCode;
     }
 
     /**
      * Sets the HTTP status code to return.
      *
      * @param statusCode the status.
      */
     @Override
     public void setStatusCode(int statusCode)
     {
         this.statusCode = statusCode;
     }
 
     /**
      * Gets an array of system errors.
      *
      * @return a SystemError[].
      */
     @Override
     public SystemError[] getSystemErrors()
     {
         SystemError[] result = new SystemError[errors.size()];
         errors.toArray(result);
         return result;
     }
 
     /**
      * Adds a critical system error.
      *
      * @param err a system error.
      */
     @Override
     public void setSystemError(SystemError err)
     {
         this.errors.add(err);
     }
 
     /**
      * Gets JNDI Contexts.
      *
      * @return a hashtable.
      */
     @Override
     public Map<String, Context> getJNDIContexts()
     {
         if (jndiContexts == null)
         {
             jndiContexts = new HashMap<String, Context>();
         }
         return jndiContexts;
     }
 
     /**
      * Sets JNDI Contexts.
      *
      * @param contexts a hashtable.
      */
     @Override
     public void setJNDIContexts(Map<String, Context> contexts)
     {
         this.jndiContexts = contexts;
     }
 
     /**
      * Gets the cached server scheme.
      *
      * @return a string.
      */
     @Override
     public String getServerScheme()
     {
         return getServerData().getServerScheme();
     }
 
     /**
      * Gets the cached server name.
      *
      * @return a string.
      */
     @Override
     public String getServerName()
     {
         return getServerData().getServerName();
     }
 
     /**
      * Gets the cached server port.
      *
      * @return an int.
      */
     @Override
     public int getServerPort()
     {
         return getServerData().getServerPort();
     }
 
     /**
      * Gets the cached context path.
      *
      * @return a string.
      */
     @Override
     public String getContextPath()
     {
         return getServerData().getContextPath();
     }
 
     /**
      * Gets the cached script name.
      *
      * @return a string.
      */
     @Override
     public String getScriptName()
     {
         return getServerData().getScriptName();
     }
 
     /**
      * Gets the server data ofy the request.
      *
      * @return server data.
      */
     @Override
     public ServerData getServerData()
     {
         return get(Turbine.class, ServerData.class);
     }
 
     /**
      * Gets the IP address of the client that sent the request.
      *
      * @return a string.
      */
     @Override
     public String getRemoteAddr()
     {
         if (this.remoteAddr == null)
         {
             this.remoteAddr = this.getRequest().getRemoteAddr();
         }
 
         return this.remoteAddr;
     }
 
     /**
      * Gets the qualified name of the client that sent the request.
      *
      * @return a string.
      */
     @Override
     public String getRemoteHost()
     {
         if (this.remoteHost == null)
         {
             this.remoteHost = this.getRequest().getRemoteHost();
         }
 
         return this.remoteHost;
     }
 
     /**
      * Get the user agent for the request. The semantics here
      * are muddled because RunData caches the value after the
      * first invocation. This is different e.g. from getCharSet().
      *
      * @return a string.
      */
     @Override
     public String getUserAgent()
     {
         if (StringUtils.isEmpty(userAgent))
         {
             userAgent = this.getRequest().getHeader("User-Agent");
         }
 
         return userAgent;
     }
 
     /**
      * Pulls a user object from the session and increments the access
      * counter and sets the last access date for the object.
      */
     @Override
     public void populate()
     {
         User user = getUserFromSession();
         get(Turbine.class).put(User.class, user);
 
         if (user != null)
         {
             user.setLastAccessDate();
             user.incrementAccessCounter();
             user.incrementAccessCounterForSession();
         }
     }
 
     /**
      * Saves a user object into the session.
      */
     @Override
     public void save()
     {
         getSession().setAttribute(User.SESSION_KEY, getUser());
     }
 
     /**
      * Gets the stack trace if set.
      *
      * @return the stack trace.
      */
     @Override
     public String getStackTrace()
     {
         return stackTrace;
     }
 
     /**
      * Gets the stack trace exception if set.
      *
      * @return the stack exception.
      */
     @Override
     public Throwable getStackTraceException()
     {
         return stackTraceException;
     }
 
     /**
      * Sets the stack trace.
      *
      * @param trace the stack trace.
      * @param exp the exception.
      */
     @Override
     public void setStackTrace(String trace, Throwable exp)
     {
         stackTrace = trace;
         stackTraceException = exp;
     }
 
     /**
      * Sets a name/value pair in an internal Map that is accessible from the
      * Error screen.  This is a good way to get debugging information
      * when an exception is thrown.
      *
      * @param name name of the variable
      * @param value value of the variable.
      */
     @Override
     public void setDebugVariable(String name, Object value)
     {
         this.debugVariables.put(name, value);
     }
 
     /**
      * Gets a Map of debug variables.
      *
      * @return a Map of debug variables.
      */
     @Override
     public Map<String, Object> getDebugVariables()
     {
         return this.debugVariables;
     }
 
     // **********************************************
     // Implementation of the TurbineRunData interface
     // **********************************************
 
     /**
      * Gets the parameter parser without parsing the parameters.
      *
      * @return the parameter parser.
      * TODO Does this method make sense? Pulling the parameter out of
      *       the run data object before setting a request (which happens
      *       only in getParameters() leads to the Parameter parser having
      *       no object and thus the default or even an undefined encoding
      *       instead of the actual request character encoding).
      */
     @Override
     public ParameterParser getParameterParser()
     {
         return get(Turbine.class, ParameterParser.class);
     }
 
     /**
      * Gets the cookie parser without parsing the cookies.
      *
      * @return the cookie parser.
      */
     @Override
     public CookieParser getCookieParser()
     {
         return get(Turbine.class, CookieParser.class);
     }
 
     // ********************
     // Miscellanous setters
     // ********************
 
     /**
      * Sets the print writer.
      *
      * @param out a print writer.
      * @deprecated no replacement planned, response writer will not be cached
      */
     @Deprecated
     protected void setOut(PrintWriter out)
     {
         this.out = out;
     }
 
     /**
      * Sets the cached server scheme that is stored in the server data.
      *
      * @param serverScheme a string.
      */
     protected void setServerScheme(String serverScheme)
     {
         getServerData().setServerScheme(serverScheme);
     }
 
     /**
      * Sets the cached server same that is stored in the server data.
      *
      * @param serverName a string.
      */
     protected void setServerName(String serverName)
     {
         getServerData().setServerName(serverName);
     }
 
     /**
      * Sets the cached server port that is stored in the server data.
      *
      * @param port an int.
      */
     protected void setServerPort(int port)
     {
         getServerData().setServerPort(port);
     }
 
     /**
      * Sets the cached context path that is stored in the server data.
      *
      * @param contextPath a string.
      */
     protected void setContextPath(String contextPath)
     {
         getServerData().setContextPath(contextPath);
     }
 
     /**
      * Sets the cached script name that is stored in the server data.
      *
      * @param scriptName a string.
      */
     protected void setScriptName(String scriptName)
     {
         getServerData().setScriptName(scriptName);
     }
 
     /**
      * Checks whether the object is disposed.
      *
      * @return true, if the object is disposed.
      */
     @Override
     public boolean isDisposed()
     {
         return disposed;
     }
 
 }