protected HttpRequest(HttpServletRequest req,
    HttpEnvironment env) 
{
                  
        super();
        this.req = req;
        this.env = env;
}

Creates a HttpRequest based on a real HttpServletRequest object

 public Object get(String name) 
{
        // if the request has been wrapped then access its method
        if (req instanceof MultipartHttpServletRequest) {
            return ((MultipartHttpServletRequest) req).get(name);
        } else {
            String[] values = req.getParameterValues(name);
            if (values == null) {
                return null;
            }
            if (values.length == 1) {
                return values[0];
            }
            if (values.length  > 1) {
                Vector vect = new Vector(values.length);
                for (int i = 0; i <  values.length; i++) {
                    vect.add(values[i]);
                }
                return vect;
            }
        }
        return null;
}

 public Object getAttribute(String name) 
{
        return this.req.getAttribute(name);
}

 public Enumeration getAttributeNames() 
{
        return this.req.getAttributeNames();
}

 public String getAuthType() 
{
        return this.req.getAuthType();
}

 public String getCharacterEncoding() 
{
        if (this.form_encoding == null) {
            return this.req.getCharacterEncoding();
        } else {
            return this.form_encoding;
        }
}

 public int getContentLength() 
{
        return this.req.getContentLength();
}

 public String getContentType() 
{
        return this.req.getContentType();
}

 public String getContextPath() 
{
        return this.req.getContextPath();
}

 public Map getCookieMap() 
{
        if (this.wrappedCookieMap == null) {
            wrapCookies();
        }
        return this.wrappedCookieMap;
}

 public Cookie[] getCookies() 
{
       
        if (this.wrappedCookieMap == null) {
            wrapCookies();
        }
        return this.wrappedCookies;
}

 public long getDateHeader(String name) 
{
        return this.req.getDateHeader(name);
}

 public String getHeader(String name) 
{
        return this.req.getHeader(name);
}

 public Enumeration getHeaderNames() 
{
        return this.req.getHeaderNames();
}

 public Enumeration getHeaders(String name) 
{
        return this.req.getHeaders(name);
}

 public ServletInputStream getInputStream() throws IOException 
{
        return this.req.getInputStream();
}

 public int getIntHeader(String name) 
{
        return this.req.getIntHeader(name);
}

 public Locale getLocale() 
{
        return this.req.getLocale();
}

 public Enumeration getLocales() 
{
        return this.req.getLocales();
}

 public String getMethod() 
{
        return this.req.getMethod();
}

 public String getParameter(String name) 
{
        String value = this.req.getParameter(name);
        if (this.form_encoding == null || this.container_encoding == null || value == null) {
            return value;
        }
        // Form and container encoding are equal, skip expensive value decoding
        if (this.container_encoding.equals(this.form_encoding)) {
            return value;
        }
        return decode(value);
}

 public Enumeration getParameterNames() 
{
        return this.req.getParameterNames();
}

 public String[] getParameterValues(String name) 
{
        String[] values = this.req.getParameterValues(name);
        if (values == null) return null;
        if (this.form_encoding == null) {
            return values;
        }
        String[] decoded_values = new String[values.length];
        for (int i = 0; i <  values.length; ++i) {
            decoded_values[i] = decode(values[i]);
        }
        return decoded_values;
}

 public String getPathInfo() 
{
        return this.req.getPathInfo();
}

 public String getPathTranslated() 
{
        return this.req.getPathTranslated();
}

 public String getProtocol() 
{
        return this.req.getProtocol();
}

 public String getQueryString() 
{
        return this.req.getQueryString();
}

 public BufferedReader getReader() throws IOException 
{
        return this.req.getReader();
}

 public String getRealPath(String path) 
{
        return this.req.getRealPath(path);
}

 public String getRemoteAddr() 
{
        return this.req.getRemoteAddr();
}

 public String getRemoteHost() 
{
        return this.req.getRemoteHost();
}

 public String getRemoteUser() 
{
        return this.req.getRemoteUser();
}

 public RequestDispatcher getRequestDispatcher(String path) 
{
        return this.req.getRequestDispatcher(path);
}

 public String getRequestURI() 
{
        if (this.reqURI == null) {
            this.reqURI = this.req.getRequestURI();
            if ( this.reqURI.equals("/") ) {
                String s = this.req.getServletPath();
                final StringBuffer buffer = new StringBuffer();
                if ( null != s ) buffer.append(s);
                s = this.req.getPathInfo();
                if ( null != s ) buffer.append(s);
                this.reqURI = buffer.toString();
            }
        }
        return this.reqURI;
}

 public String getRequestedSessionId() 
{
        return this.req.getRequestedSessionId();
}

 public String getScheme() 
{
        return this.req.getScheme();
}

 public String getServerName() 
{
        return this.req.getServerName();
}

 public int getServerPort() 
{
        return this.req.getServerPort();
}

 public String getServletPath() 
{
        return this.req.getServletPath();
}

 public Session getSession() 
{
        return this.getSession(true);
}

 public Session getSession(boolean create) 
{
        javax.servlet.http.HttpSession serverSession = this.req.getSession(create);
        HttpSession session;
        if (serverSession != null) {
            synchronized (sessions) {
                // retrieve existing wrapper
                WeakReference ref = (WeakReference)sessions.get(serverSession);
                if (ref == null || (session = (HttpSession)ref.get()) == null) {
                    // create new wrapper
                    session = new HttpSession(serverSession);
                    sessions.put(serverSession, new WeakReference(session));
                }
            }
        } else {
            // invalidate
            session = null;
        }
        return session;
}

Creates a wrapper implementing Session for javax.servlet.http.HttpSession . The method must assure 1:1-mapping of javax.servlet.http.HttpSession s to Cocoon's session wrappers.

 public String getSitemapURI() 
{
        return this.env.getURI();
}

 public String getSitemapURIPrefix() 
{
        return this.env.getURIPrefix();
}

 public Principal getUserPrincipal() 
{
        return this.req.getUserPrincipal();
}

 public boolean isRequestedSessionIdFromCookie() 
{
        return this.req.isRequestedSessionIdFromCookie();
}

 public boolean isRequestedSessionIdFromURL() 
{
        return this.req.isRequestedSessionIdFromURL();
}

 public boolean isRequestedSessionIdFromUrl() 
{
        return this.req.isRequestedSessionIdFromURL();
}

 public boolean isRequestedSessionIdValid() 
{
        return this.req.isRequestedSessionIdValid();
}

 public boolean isSecure() 
{
        return this.req.isSecure();
}

 public boolean isUserInRole(String role) 
{
        return this.req.isUserInRole(role);
}

 public  void removeAttribute(String name) 
{
        this.req.removeAttribute(name);
}

 public  void setAttribute(String name,
    Object o) 
{
        this.req.setAttribute(name, o);
}

 public  void setCharacterEncoding(String form_encoding) throws UnsupportedEncodingException 
{
        this.form_encoding = form_encoding;
}

 public  void setContainerEncoding(String container_encoding) 
{
        this.container_encoding = container_encoding;
}

Sets the default encoding of the servlet container.