Coverage Report

Coverage Report - org.melati.util.HttpServletRequestCompat

Classes in this File
Line Coverage
Branch Coverage
Complexity
HttpServletRequestCompat
31%
29/94
33%
4/12
1.465
HttpServletRequestCompat$MissingMethodError
0/2
N/A
1.465
 /*
  * $Source: /usr/cvsroot/melati/melati/src/main/java/org/melati/util/HttpServletRequestCompat.java,v $
  * $Revision: 1.10 $
  *
  * Copyright (C) 2001 William Chesters
  *
  * Part of Melati (http://melati.org), a framework for the rapid
  * development of clean, maintainable web applications.
  *
  * Melati is free software; Permission is granted to copy, distribute
  * and/or modify this software under the terms either:
  *
  * a) the GNU General Public License as published by the Free Software
  *    Foundation; either version 2 of the License, or (at your option)
  *    any later version,
  *
  *    or
  *
  * b) any version of the Melati Software License, as published
  *    at http://melati.org
  *
  * You should have received a copy of the GNU General Public License and
  * the Melati Software License along with this program;
  * if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
  * GNU General Public License and visit http://melati.org to obtain the
  * Melati Software License.
  *
  * Feel free to contact the Developers of Melati (http://melati.org),
  * if you would like to work out a different arrangement than the options
  * outlined here.  It is our intention to allow Melati to be used by as
  * wide an audience as possible.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * Contact details for copyright holder:
  *
  *     William Chesters <williamc At paneris.org>
  *     http://paneris.org/~williamc
  *     Obrechtstraat 114, 2517VX Den Haag, The Netherlands
  */
 
 package org.melati.util;
 
 import java.util.Map;
 import java.util.Enumeration;
 import java.util.Locale;
 import javax.servlet.RequestDispatcher;
 import javax.servlet.http.HttpSession;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.Cookie;
 import java.lang.reflect.Method;
 import java.lang.reflect.InvocationTargetException;
 
 /**
  * The <code>HttpServletRequestCompat</code> class enables Melati to compile,
  * without warnings, with the Servlet API versions 2.0 to 2.5.
  * 
  * The core methods are those present in the 2.0 API all methods added since 
  * are established as static members. 
  * These are then available to be invoked if present or a RuntimeException is thrown
  * otherwise.
  * 
  * However, if you use a method which is not in your version of the API then you
  * will get a runtime exception.
  * 
  * @see org.melati.util.DelegatedHttpServletRequest
  */
 
 public final class HttpServletRequestCompat {
   private static final long serialVersionUID = 1L;
 
   private HttpServletRequestCompat() {
   }
 
   /** Deprecated in Servlet 2.1 API. */
   private static Method isRequestedSessionIdFromUrl, getRealPath;
 
   /** New in Servlet 2.2 API. */
   private static Method getUserPrincipal, getContextPath, getHeaders,
       getSession, isRequestedSessionIdFromURL, isUserInRole, getAttributeNames,
       getLocale, getLocales, getRequestDispatcher, isSecure, removeAttribute,
       setAttribute;
   /** New in Servlet 2.3 API. */
   private static Method getRequestURL, setCharacterEncoding, getParameterMap;
   /** New in Servlet 2.4 API. */
   private static Method getLocalAddr, getLocalName, getLocalPort, getRemotePort;
   
   private static Method methodOrNull(Class c, String n, String[] pn) {
     try {
       Class[] p = new Class[pn.length];
       for (int i = 0; i < pn.length; ++i)
         p[i] = Class.forName(pn[i]);
       return c.getMethod(n, p);
     } catch (NoSuchMethodException e) {
       return null;
     } catch (ClassNotFoundException e) {
       return null;
     }
   }
 
   static {
     try {
       String[] noparams = {};
 
       Class hsr = Class.forName("javax.servlet.http.HttpServletRequest");
       getUserPrincipal = methodOrNull(hsr, "getUserPrincipal", noparams);
       getContextPath = methodOrNull(hsr, "getContextPath", noparams);
       getHeaders = methodOrNull(hsr, "getHeaders",
           new String[] { "java.lang.String" });
       getSession = methodOrNull(hsr, "getSession", noparams);
       isRequestedSessionIdFromURL = methodOrNull(hsr,
           "isRequestedSessionIdFromURL", noparams);
       isUserInRole = methodOrNull(hsr, "isUserInRole",
           new String[] { "java.lang.String" });
       getAttributeNames = methodOrNull(hsr, "getAttributeNames", noparams);
       getLocale = methodOrNull(hsr, "getLocale", noparams);
       getLocales = methodOrNull(hsr, "getLocales", noparams);
       getRequestDispatcher = methodOrNull(hsr, "getRequestDispatcher",
           new String[] { "java.lang.String" });
       isSecure = methodOrNull(hsr, "isSecure", noparams);
       removeAttribute = methodOrNull(hsr, "removeAttribute",
           new String[] { "java.lang.String" });
       setAttribute = methodOrNull(hsr, "setAttribute", new String[] {
           "java.lang.String", "java.lang.Object" });
       
       getLocalAddr = methodOrNull(hsr, "getLocalAddr", noparams);
       getLocalName = methodOrNull(hsr, "getLocalName", noparams);
       getLocalPort = methodOrNull(hsr, "getLocalPort", noparams);
       getRemotePort = methodOrNull(hsr, "getRemotePort", noparams);
       
     } catch (Exception e) {
       e.printStackTrace();
       throw new Error("org.melati.util.servletcompat.HttpServletRequestCompat"
           + "failed to initialize; contact the Melati developers");
     }
   }
   // 
   // ================================
   // Original Servlet API 2.0 methods 
   // ================================
   // 
 
   /**
    * Returns the name of the authentication scheme used to protect the servlet,
    * for example, "BASIC" or "SSL," or <code>null</code> if the servlet was
    * not protected. <p>Same as the value of the CGI variable AUTH_TYPE.
    * 
    * @param it
    *        the HttpServletRequest
    * @return a <code>String</code> specifying the name of the authentication
    *         scheme, or <code>null</code> if the request was not authenticated
    * @see javax.servlet.http.HttpServletRequest#getAuthType()
    * @since 2.0
    */
   public static String getAuthType(HttpServletRequest it) {
     return it.getAuthType();
   }
 
   /**
    * Returns an array containing all of the <code>Cookie</code> objects the
    * client sent with this request. This method returns <code>null</code> if
    * no cookies were sent.
    * 
    * @param it
    *        the HttpServletRequest
    * @return an array of all the <code>Cookies</code> included with this
    *         request, or <code>null</code> if the request has no cookies
    * @see javax.servlet.http.HttpServletRequest#getCookies()
    * @since 2.0
    */
   public static Cookie[] getCookies(HttpServletRequest it) {
     return it.getCookies();
   }
 
   /**
    * Returns the value of the specified request header as a <code>long</code>
    * value that represents a <code>Date</code> object. Use this method with
    * headers that contain dates, such as <code>If-Modified-Since</code>. <p>The
    * date is returned as the number of milliseconds since January 1, 1970 GMT.
    * The header name is case insensitive. <p>If the request did not have a
    * header of the specified name, this method returns -1. If the header can't
    * be converted to a date, the method throws an
    * <code>IllegalArgumentException</code>.
    * 
    * @param it
    *        the HttpServletRequest
    * @return a <code>long</code> value representing the date specified in the
    *         header expressed as the number of milliseconds since January 1,
    *         1970 GMT, or -1 if the named header was not included with the
    *         reqest
    * @see javax.servlet.http.HttpServletRequest#getDateHeader(String)
    * @since 2.0
    */
   public static long getDateHeader(HttpServletRequest it, String a) {
     return it.getDateHeader(a);
   }
 
   /**
    * Returns the value of the specified request header as a <code>String</code>.
    * If the request did not include a header of the specified name, this method
    * returns <code>null</code>. The header name is case insensitive. You can
    * use this method with any request header.
    * 
    * @param it
    *        the HttpServletRequest
    * @return a <code>String</code> containing the value of the requested
    *         header, or <code>null</code> if the request does not have a
    *         header of that name
    * @see javax.servlet.http.HttpServletRequest#getHeader(String)
    * @since 2.0
    */
   public static String getHeader(HttpServletRequest it, String a) {
     return it.getHeader(a);
   }
 
   /**
    * Returns an enumeration of all the header names this request contains. If
    * the request has no headers, this method returns an empty enumeration. <p>Some
    * servlet containers do not allow do not allow servlets to access headers
    * using this method, in which case this method returns <code>null</code>
    * 
    * @param it
    *        the HttpServletRequest
    * @return an enumeration of all the header names sent with this request; if
    *         the request has no headers, an empty enumeration; if the servlet
    *         container does not allow servlets to use this method,
    *         <code>null</code>
    * @see javax.servlet.http.HttpServletRequest#getHeaderNames()
    * @since 2.0
    */
   public static Enumeration getHeaderNames(HttpServletRequest it) {
     return it.getHeaderNames();
   }
 
   /**
    * Returns the value of the specified request header as an <code>int</code>.
    * If the request does not have a header of the specified name, this method
    * returns -1. If the header cannot be converted to an integer, this method
    * throws a <code>NumberFormatException</code>. <p>The header name is case
    * insensitive.
    * 
    * @param it
    *        the HttpServletRequest
    * @return an integer expressing the value of the request header or -1 if the
    *         request doesn't have a header of this name
    * @see javax.servlet.http.HttpServletRequest#getIntHeader(String)
    * @since 2.0
    */
   public static int getIntHeader(HttpServletRequest it, String a) {
     return it.getIntHeader(a);
   }
 
   /**
    * @param it the HttpServletRequest
    * @return      a <code>String</code> 
    *        specifying the name
    *        of the method with which
    *        this request was made
    * @see javax.servlet.http.HttpServletRequest#getMethod()
    * @since 2.0
    */
   public static String getMethod(HttpServletRequest it) {
     return it.getMethod();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> specifying 
    *      extra path information that comes
    *      after the servlet path but before
    *      the query string in the request URL;
    *      or <code>null</code> if the URL does not have
    *      any extra path information
    * @see javax.servlet.http.HttpServletRequest#getPathInfo()
    * @since 2.0
    */
   public static String getPathInfo(HttpServletRequest it) {
     return it.getPathInfo();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> specifying the
    *      real path, or <code>null</code> if
    *      the URL does not have any extra path
    *      information
    * @see javax.servlet.http.HttpServletRequest#getPathTranslated()
    * @since 2.0
    */
   public static String getPathTranslated(HttpServletRequest it) {
     return it.getPathTranslated();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> containing the query
    *      string or <code>null</code> if the URL 
    *      contains no query string
    * @see javax.servlet.http.HttpServletRequest#getQueryString()
    * @since 2.0
    */
   public static String getQueryString(HttpServletRequest it) {
     return it.getQueryString();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> specifying the login
    *      of the user making this request, or <code>null</code>
    *      if the user login is not known
    * @see javax.servlet.http.HttpServletRequest#getRemoteUser()
    * @since 2.0
    */
   public static String getRemoteUser(HttpServletRequest it) {
     return it.getRemoteUser();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> containing
    *      the part of the URL from the 
    *      protocol name up to the query string
    * @see javax.servlet.http.HttpServletRequest#getRequestURI()
    * @since 2.0
    */
   public static String getRequestURI(HttpServletRequest it) {
     return it.getRequestURI();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> specifying the session
    *      ID, or <code>null</code> if the request did
    *      not specify a session ID
    * @see javax.servlet.http.HttpServletRequest#getRequestedSessionId()
    * @since 2.0
    */
   public static String getRequestedSessionId(HttpServletRequest it) {
     return it.getRequestedSessionId();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return    a <code>String</code> containing
    *      the name or path of the servlet being
    *      called, as specified in the request URL 
    * @see javax.servlet.http.HttpServletRequest#getServletPath()
    * @since 2.0
    */
   public static String getServletPath(HttpServletRequest it) {
     return it.getServletPath();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @param a
    * @return    the <code>HttpSession</code> associated
    *      with this request
    * @see javax.servlet.http.HttpServletRequest#getSession()
    * @since 2.0
    */
   public static HttpSession getSession(HttpServletRequest it, boolean a) {
     return it.getSession(a);
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return      <code>true</code> if this
    *        request has an id for a valid session
    *        in the current session context;
    *        <code>false</code> otherwise
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdValid()
    * @since 2.0
    */
   public static boolean isRequestedSessionIdValid(HttpServletRequest it) {
     return it.isRequestedSessionIdValid();
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return      <code>true</code> if the session ID
    *        came in as a
    *        cookie; otherwise, <code>false</code>
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromCookie()
    * @since 2.0
    */
   public static boolean isRequestedSessionIdFromCookie(HttpServletRequest it) {
     return it.isRequestedSessionIdFromCookie();
   }
   
   //======================
   // Invocation machinery
   //======================
   
   /**
    * Thrown when a method that is not available is invoked.
    */
   public static class MissingMethodError extends NoSuchMethodError {
     private static final long serialVersionUID = 1L;
 
     /**
      * {@inheritDoc}
      * 
      * @see java.lang.Throwable#getMessage()
      */
     public String getMessage() {
       return "The application tried to use a method from the "
           + "Servlet API which is not present in the version it running against.";
     }
   }
 
   private static Object invoke(Method method, HttpServletRequest it,
       Object[] args) {
     if (method == null)
       throw new MissingMethodError();
     else {
       try {
         return method.invoke(it, args);
       } catch (InvocationTargetException e) {
         Throwable f = e.getTargetException();
         if (f instanceof RuntimeException) // they all should be
           throw (RuntimeException)f;
         else if (f instanceof Exception)
           throw new RuntimeException("while invoking a Servlet API method",
                                      f);
         else if (f instanceof Error)
           throw (Error)f;
         else {
           f.printStackTrace();
           throw new Error("totally unexpected kind of throwable in "
               + "org.melati.util.servletcompat.HttpServletRequestCompat");
         }
       } catch (IllegalAccessException e) {
         e.printStackTrace();
         throw new Error(
                         "org.melati.util.servletcompat.HttpServletRequestCompat"
                             + "got an unexpected IllegalAccessException trying to "
                             + "invoke a method; contact the Melati developers");
       }
     }
   }
 
   private static final Object[] noargs = {};
 
   // 
   // ============================
   // Servlet API 2.1 deprecatons
   // ============================
   // 
 
   /**
    * @param it
    *        the HttpServletRequest
    * @param arg
    *        url String
    * @return the real path
    * @deprecated Servlet API 2.1
    * @see javax.servlet.ServletRequest#getRealPath(String)
    * @since 2.0
    */
   public static String getRealPath(HttpServletRequest it, String arg) {
     return (String)invoke(getRealPath, it, new Object[] { arg });
   }
 
   /**
    * @param it
    *        the HttpServletRequest
    * @return whether id is from url
    * @deprecated Servlet API 2.1 
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromUrl()
    * @since 2.0
    */
   public static boolean isRequestedSessionIdFromUrl(HttpServletRequest it) {
     return ((Boolean)invoke(isRequestedSessionIdFromUrl, it, noargs))
         .booleanValue();
   }
 
   // 
   // ============================
   // Servlet API 2.1 extensions
   // ============================
   // 
 
   /**
    * Returns the empty string when run against 2.0 API.
    * 
    * @param it
    *        the HttpServletRequest
    * @return the Context path or empty string
    * @see javax.servlet.http.HttpServletRequest#getContextPath()
    * @since 2.1
    */
   public static String getContextPath(HttpServletRequest it) {
     if (getContextPath == null)
       return "";
     else
       return (String)invoke(getContextPath, it, noargs);
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
    * 
    * @param it
    *        the HttpServletRequest
    * @return    a <code>java.security.Principal</code> containing
    *      the name of the user making this request;
    *      <code>null</code> if the user has not been 
    *      authenticated
    * @see javax.servlet.http.HttpServletRequest#getUserPrincipal()
    * @since 2.1
    */
   public static java.security.Principal getUserPrincipal(HttpServletRequest it) {
     return (java.security.Principal)invoke(getUserPrincipal, it, noargs);
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
    * 
    * @param it
    *        the HttpServletRequest
    * @param arg
    * @return      a <code>Enumeration</code> containing the
    *        values of the requested
    *        header, or <code>null</code>
    *        if the request does not
    *        have any headers of that name
    * @see javax.servlet.http.HttpServletRequest#getHeaders(java.lang.String)
    * @since 2.1
    */
   public static Enumeration getHeaders(HttpServletRequest it, String arg) {
     return (Enumeration)invoke(getHeaders, it, new Object[] { arg });
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API, 
    * introduced in 2.1.
    * 
    * @param it
    *        the HttpServletRequest
    * @return    the <code>HttpSession</code> associated
    *      with this request
    * @see javax.servlet.http.HttpServletRequest#getSession()
    * @since 2.1
    */
   public static HttpSession getSession(HttpServletRequest it) {
     return (HttpSession)invoke(getSession, it, noargs);
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API, 
    * introduced in 2.1.
    * 
    * @param it
    *        the HttpServletRequest
    * @return      <code>true</code> if the session ID
    *        came in as part of a URL; otherwise,
    *        <code>false</code>
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromURL()
    * @since 2.1
    */
   public static boolean isRequestedSessionIdFromURL(HttpServletRequest it) {
     return ((Boolean)invoke(isRequestedSessionIdFromURL, it, noargs))
         .booleanValue();
   }
 
   // 
   // ============================
   // Servlet API 2.2 extensions
   // ============================
   // 
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
    * 
    * @param it
    *        the HttpServletRequest
    * @param arg
    * @return    a <code>boolean</code> indicating whether
    *      the user making this request belongs to a given role;
    *      <code>false</code> if the user has not been 
    *      authenticated
    * @see javax.servlet.http.HttpServletRequest#isUserInRole(java.lang.String)
    * @since 2.2
    */
   public static boolean isUserInRole(HttpServletRequest it, String arg) {
     return ((Boolean)invoke(isUserInRole, it, new Object[] { arg }))
         .booleanValue();
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns an
    * <code>Enumeration</code> containing the names of the attributes available
    * to this request. This method returns an empty <code>Enumeration</code> if
    * the request has no attributes available to it.
    * 
    * @param it
    *        the HttpServletRequest
    * @return an <code>Enumeration</code> of strings containing the names of
    *         the request's attributes
    * @see javax.servlet.http.HttpServletRequest#getAttributeNames()
    * @since 2.2
    */
   public static Enumeration getAttributeNames(HttpServletRequest it) {
     return (Enumeration)invoke(getAttributeNames, it, noargs);
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns the
    * preferred <code>Locale</code> that the client will accept content in,
    * based on the Accept-Language header. If the client request doesn't provide
    * an Accept-Language header, this method returns the default locale for the
    * server.
    * 
    * @param it
    *        the HttpServletRequest
    * @return the preferred <code>Locale</code> for the client
    * @see javax.servlet.http.HttpServletRequest#getLocale()
    * @since 2.2
    */
   public static Locale getLocale(HttpServletRequest it) {
     return (Locale)invoke(getLocale, it, noargs);
   }
 
   /**
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns an
    * <code>Enumeration</code> of <code>Locale</code> objects indicating, in
