Coverage Report - org.melati.util.HttpServletRequestCompat
 
Classes in this File Line Coverage Branch Coverage Complexity
HttpServletRequestCompat
0%
0/94
0%
0/12
1.465
HttpServletRequestCompat$MissingMethodError
0%
0/2
N/A
1.465
 
 1  
 /*
 2  
  * $Source: /usr/cvsroot/melati/melati/src/site/resources/withWebmacro/org.melati.util.HttpServletRequestCompat.html,v $
 3  
  * $Revision: 1.1 $
 4  
  *
 5  
  * Copyright (C) 2001 William Chesters
 6  
  *
 7  
  * Part of Melati (http://melati.org), a framework for the rapid
 8  
  * development of clean, maintainable web applications.
 9  
  *
 10  
  * Melati is free software; Permission is granted to copy, distribute
 11  
  * and/or modify this software under the terms either:
 12  
  *
 13  
  * a) the GNU General Public License as published by the Free Software
 14  
  *    Foundation; either version 2 of the License, or (at your option)
 15  
  *    any later version,
 16  
  *
 17  
  *    or
 18  
  *
 19  
  * b) any version of the Melati Software License, as published
 20  
  *    at http://melati.org
 21  
  *
 22  
  * You should have received a copy of the GNU General Public License and
 23  
  * the Melati Software License along with this program;
 24  
  * if not, write to the Free Software Foundation, Inc.,
 25  
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
 26  
  * GNU General Public License and visit http://melati.org to obtain the
 27  
  * Melati Software License.
 28  
  *
 29  
  * Feel free to contact the Developers of Melati (http://melati.org),
 30  
  * if you would like to work out a different arrangement than the options
 31  
  * outlined here.  It is our intention to allow Melati to be used by as
 32  
  * wide an audience as possible.
 33  
  *
 34  
  * This program is distributed in the hope that it will be useful,
 35  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 36  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 37  
  * GNU General Public License for more details.
 38  
  *
 39  
  * Contact details for copyright holder:
 40  
  *
 41  
  *     William Chesters <williamc At paneris.org>
 42  
  *     http://paneris.org/~williamc
 43  
  *     Obrechtstraat 114, 2517VX Den Haag, The Netherlands
 44  
  */
 45  
 
 46  
 package org.melati.util;
 47  
 
 48  
 import java.util.Map;
 49  
 import java.util.Enumeration;
 50  
 import java.util.Locale;
 51  
 import javax.servlet.RequestDispatcher;
 52  
 import javax.servlet.http.HttpSession;
 53  
 import javax.servlet.http.HttpServletRequest;
 54  
 import javax.servlet.http.Cookie;
 55  
 import java.lang.reflect.Method;
 56  
 import java.lang.reflect.InvocationTargetException;
 57  
 
 58  
 /**
 59  
  * NOTE This is no longer used, but it is so cool it is still around to marvel at
 60  
  * 
 61  
  * The <code>HttpServletRequestCompat</code> class enables Melati to compile,
 62  
  * without warnings, with the Servlet API versions 2.0 to 2.5.
 63  
  * 
 64  
  * The core methods are those present in the 2.0 API all methods added since 
 65  
  * are established as static members. 
 66  
  * These are then available to be invoked if present or a RuntimeException is thrown
 67  
  * otherwise.
 68  
  * 
 69  
  * However, if you use a method which is not in your version of the API then you
 70  
  * will get a runtime exception.
 71  
  * 
 72  
  * @see org.melati.util.DelegatedHttpServletRequest
 73  
  */
 74  
 
 75  
 public final class HttpServletRequestCompat {
 76  
   private static final long serialVersionUID = 1L;
 77  
 
 78  0
   private HttpServletRequestCompat() {
 79  0
   }
 80  
 
 81  
   /** Deprecated in Servlet 2.1 API. */
 82  
   private static Method isRequestedSessionIdFromUrl, getRealPath;
 83  
 
 84  
   /** New in Servlet 2.2 API. */
 85  
   private static Method getUserPrincipal, getContextPath, getHeaders,
 86  
       getSession, isRequestedSessionIdFromURL, isUserInRole, getAttributeNames,
 87  
       getLocale, getLocales, getRequestDispatcher, isSecure, removeAttribute,
 88  
       setAttribute;
 89  
   /** New in Servlet 2.3 API. */
 90  
   private static Method getRequestURL, setCharacterEncoding, getParameterMap;
 91  
   /** New in Servlet 2.4 API. */
 92  
   private static Method getLocalAddr, getLocalName, getLocalPort, getRemotePort;
 93  
   
 94  
   private static Method methodOrNull(Class<?> c, String n, String[] pn) {
 95  
     try {
 96  0
       Class<?>[] p = new Class[pn.length];
 97  0
       for (int i = 0; i < pn.length; ++i)
 98  0
         p[i] = Class.forName(pn[i]);
 99  0
       return c.getMethod(n, p);
 100  0
     } catch (NoSuchMethodException e) {
 101  0
       return null;
 102  0
     } catch (ClassNotFoundException e) {
 103  0
       return null;
 104  
     }
 105  
   }
 106  
 
 107  
   static {
 108  
     try {
 109  0
       String[] noparams = {};
 110  
 
 111  0
       Class<?> hsr = Class.forName("javax.servlet.http.HttpServletRequest");
 112  0
       getUserPrincipal = methodOrNull(hsr, "getUserPrincipal", noparams);
 113  0
       getContextPath = methodOrNull(hsr, "getContextPath", noparams);
 114  0
       getHeaders = methodOrNull(hsr, "getHeaders",
 115  
           new String[] { "java.lang.String" });
 116  0
       getSession = methodOrNull(hsr, "getSession", noparams);
 117  0
       isRequestedSessionIdFromURL = methodOrNull(hsr,
 118  
           "isRequestedSessionIdFromURL", noparams);
 119  0
       isUserInRole = methodOrNull(hsr, "isUserInRole",
 120  
           new String[] { "java.lang.String" });
 121  0
       getAttributeNames = methodOrNull(hsr, "getAttributeNames", noparams);
 122  0
       getLocale = methodOrNull(hsr, "getLocale", noparams);
 123  0
       getLocales = methodOrNull(hsr, "getLocales", noparams);
 124  0
       getRequestDispatcher = methodOrNull(hsr, "getRequestDispatcher",
 125  
           new String[] { "java.lang.String" });
 126  0
       isSecure = methodOrNull(hsr, "isSecure", noparams);
 127  0
       removeAttribute = methodOrNull(hsr, "removeAttribute",
 128  
           new String[] { "java.lang.String" });
 129  0
       setAttribute = methodOrNull(hsr, "setAttribute", new String[] {
 130  
           "java.lang.String", "java.lang.Object" });
 131  
       
 132  0
       getLocalAddr = methodOrNull(hsr, "getLocalAddr", noparams);
 133  0
       getLocalName = methodOrNull(hsr, "getLocalName", noparams);
 134  0
       getLocalPort = methodOrNull(hsr, "getLocalPort", noparams);
 135  0
       getRemotePort = methodOrNull(hsr, "getRemotePort", noparams);
 136  
       
 137  0
     } catch (Exception e) {
 138  0
       e.printStackTrace();
 139  0
       throw new Error("org.melati.util.servletcompat.HttpServletRequestCompat"
 140  
           + "failed to initialize; contact the Melati developers");
 141  0
     }
 142  
   }
 143  
   // 
 144  
   // ================================
 145  
   // Original Servlet API 2.0 methods 
 146  
   // ================================
 147  
   // 
 148  
 
 149  
   /**
 150  
    * Returns the name of the authentication scheme used to protect the servlet,
 151  
    * for example, "BASIC" or "SSL," or <code>null</code> if the servlet was
 152  
    * not protected. <p>Same as the value of the CGI variable AUTH_TYPE.
 153  
    * 
 154  
    * @param it
 155  
    *        the HttpServletRequest
 156  
    * @return a <code>String</code> specifying the name of the authentication
 157  
    *         scheme, or <code>null</code> if the request was not authenticated
 158  
    * @see javax.servlet.http.HttpServletRequest#getAuthType()
 159  
    * @since 2.0
 160  
    */
 161  
   public static String getAuthType(HttpServletRequest it) {
 162  0
     return it.getAuthType();
 163  
   }
 164  
 
 165  
   /**
 166  
    * Returns an array containing all of the <code>Cookie</code> objects the
 167  
    * client sent with this request. This method returns <code>null</code> if
 168  
    * no cookies were sent.
 169  
    * 
 170  
    * @param it
 171  
    *        the HttpServletRequest
 172  
    * @return an array of all the <code>Cookies</code> included with this
 173  
    *         request, or <code>null</code> if the request has no cookies
 174  
    * @see javax.servlet.http.HttpServletRequest#getCookies()
 175  
    * @since 2.0
 176  
    */
 177  
   public static Cookie[] getCookies(HttpServletRequest it) {
 178  0
     return it.getCookies();
 179  
   }
 180  
 
 181  
   /**
 182  
    * Returns the value of the specified request header as a <code>long</code>
 183  
    * value that represents a <code>Date</code> object. Use this method with
 184  
    * headers that contain dates, such as <code>If-Modified-Since</code>. <p>The
 185  
    * date is returned as the number of milliseconds since January 1, 1970 GMT.
 186  
    * The header name is case insensitive. <p>If the request did not have a
 187  
    * header of the specified name, this method returns -1. If the header can't
 188  
    * be converted to a date, the method throws an
 189  
    * <code>IllegalArgumentException</code>.
 190  
    * 
 191  
    * @param it
 192  
    *        the HttpServletRequest
 193  
    * @return a <code>long</code> value representing the date specified in the
 194  
    *         header expressed as the number of milliseconds since January 1,
 195  
    *         1970 GMT, or -1 if the named header was not included with the
 196  
    *         request
 197  
    * @see javax.servlet.http.HttpServletRequest#getDateHeader(String)
 198  
    * @since 2.0
 199  
    */
 200  
   public static long getDateHeader(HttpServletRequest it, String a) {
 201  0
     return it.getDateHeader(a);
 202  
   }
 203  
 
 204  
   /**
 205  
    * Returns the value of the specified request header as a <code>String</code>.
 206  
    * If the request did not include a header of the specified name, this method
 207  
    * returns <code>null</code>. The header name is case insensitive. You can
 208  
    * use this method with any request header.
 209  
    * 
 210  
    * @param it
 211  
    *        the HttpServletRequest
 212  
    * @return a <code>String</code> containing the value of the requested
 213  
    *         header, or <code>null</code> if the request does not have a
 214  
    *         header of that name
 215  
    * @see javax.servlet.http.HttpServletRequest#getHeader(String)
 216  
    * @since 2.0
 217  
    */
 218  
   public static String getHeader(HttpServletRequest it, String a) {
 219  0
     return it.getHeader(a);
 220  
   }
 221  
 
 222  
   /**
 223  
    * Returns an enumeration of all the header names this request contains. If
 224  
    * the request has no headers, this method returns an empty enumeration. <p>Some
 225  
    * servlet containers do not allow do not allow servlets to access headers
 226  
    * using this method, in which case this method returns <code>null</code>
 227  
    * 
 228  
    * @param it
 229  
    *        the HttpServletRequest
 230  
    * @return an enumeration of all the header names sent with this request; if
 231  
    *         the request has no headers, an empty enumeration; if the servlet
 232  
    *         container does not allow servlets to use this method,
 233  
    *         <code>null</code>
 234  
    * @see javax.servlet.http.HttpServletRequest#getHeaderNames()
 235  
    * @since 2.0
 236  
    */
 237  
   @SuppressWarnings("unchecked")
 238  
   public static Enumeration<String> getHeaderNames(HttpServletRequest it) {
 239  0
     return it.getHeaderNames();
 240  
   }
 241  
 
 242  
   /**
 243  
    * Returns the value of the specified request header as an <code>int</code>.
 244  
    * If the request does not have a header of the specified name, this method
 245  
    * returns -1. If the header cannot be converted to an integer, this method
 246  
    * throws a <code>NumberFormatException</code>. <p>The header name is case
 247  
    * insensitive.
 248  
    * 
 249  
    * @param it
 250  
    *        the HttpServletRequest
 251  
    * @return an integer expressing the value of the request header or -1 if the
 252  
    *         request doesn't have a header of this name
 253  
    * @see javax.servlet.http.HttpServletRequest#getIntHeader(String)
 254  
    * @since 2.0
 255  
    */
 256  
   public static int getIntHeader(HttpServletRequest it, String a) {
 257  0
     return it.getIntHeader(a);
 258  
   }
 259  
 
 260  
   /**
 261  
    * @param it the HttpServletRequest
 262  
    * @return      a <code>String</code> 
 263  
    *        specifying the name
 264  
    *        of the method with which
 265  
    *        this request was made
 266  
    * @see javax.servlet.http.HttpServletRequest#getMethod()
 267  
    * @since 2.0
 268  
    */
 269  
   public static String getMethod(HttpServletRequest it) {
 270  0
     return it.getMethod();
 271  
   }
 272  
 
 273  
   /**
 274  
    * @param it
 275  
    *        the HttpServletRequest
 276  
    * @return    a <code>String</code> specifying 
 277  
    *      extra path information that comes
 278  
    *      after the servlet path but before
 279  
    *      the query string in the request URL;
 280  
    *      or <code>null</code> if the URL does not have
 281  
    *      any extra path information
 282  
    * @see javax.servlet.http.HttpServletRequest#getPathInfo()
 283  
    * @since 2.0
 284  
    */
 285  
   public static String getPathInfo(HttpServletRequest it) {
 286  0
     return it.getPathInfo();
 287  
   }
 288  
 
 289  
   /**
 290  
    * @param it
 291  
    *        the HttpServletRequest
 292  
    * @return    a <code>String</code> specifying the
 293  
    *      real path, or <code>null</code> if
 294  
    *      the URL does not have any extra path
 295  
    *      information
 296  
    * @see javax.servlet.http.HttpServletRequest#getPathTranslated()
 297  
    * @since 2.0
 298  
    */
 299  
   public static String getPathTranslated(HttpServletRequest it) {
 300  0
     return it.getPathTranslated();
 301  
   }
 302  
 
 303  
   /**
 304  
    * @param it
 305  
    *        the HttpServletRequest
 306  
    * @return    a <code>String</code> containing the query
 307  
    *      string or <code>null</code> if the URL 
 308  
    *      contains no query string
 309  
    * @see javax.servlet.http.HttpServletRequest#getQueryString()
 310  
    * @since 2.0
 311  
    */
 312  
   public static String getQueryString(HttpServletRequest it) {
 313  0
     return it.getQueryString();
 314  
   }
 315  
 
 316  
   /**
 317  
    * @param it
 318  
    *        the HttpServletRequest
 319  
    * @return    a <code>String</code> specifying the login
 320  
    *      of the user making this request, or <code>null</code>
 321  
    *      if the user login is not known
 322  
    * @see javax.servlet.http.HttpServletRequest#getRemoteUser()
 323  
    * @since 2.0
 324  
    */
 325  
   public static String getRemoteUser(HttpServletRequest it) {
 326  0
     return it.getRemoteUser();
 327  
   }
 328  
 
 329  
   /**
 330  
    * @param it
 331  
    *        the HttpServletRequest
 332  
    * @return    a <code>String</code> containing
 333  
    *      the part of the URL from the 
 334  
    *      protocol name up to the query string
 335  
    * @see javax.servlet.http.HttpServletRequest#getRequestURI()
 336  
    * @since 2.0
 337  
    */
 338  
   public static String getRequestURI(HttpServletRequest it) {
 339  0
     return it.getRequestURI();
 340  
   }
 341  
 
 342  
   /**
 343  
    * @param it
 344  
    *        the HttpServletRequest
 345  
    * @return    a <code>String</code> specifying the session
 346  
    *      ID, or <code>null</code> if the request did
 347  
    *      not specify a session ID
 348  
    * @see javax.servlet.http.HttpServletRequest#getRequestedSessionId()
 349  
    * @since 2.0
 350  
    */
 351  
   public static String getRequestedSessionId(HttpServletRequest it) {
 352  0
     return it.getRequestedSessionId();
 353  
   }
 354  
 
 355  
   /**
 356  
    * @param it
 357  
    *        the HttpServletRequest
 358  
    * @return    a <code>String</code> containing
 359  
    *      the name or path of the servlet being
 360  
    *      called, as specified in the request URL 
 361  
    * @see javax.servlet.http.HttpServletRequest#getServletPath()
 362  
    * @since 2.0
 363  
    */
 364  
   public static String getServletPath(HttpServletRequest it) {
 365  0
     return it.getServletPath();
 366  
   }
 367  
 
 368  
   /**
 369  
    * @param it
 370  
    *        the HttpServletRequest
 371  
    * @param a
 372  
    * @return    the <code>HttpSession</code> associated
 373  
    *      with this request
 374  
    * @see javax.servlet.http.HttpServletRequest#getSession()
 375  
    * @since 2.0
 376  
    */
 377  
   public static HttpSession getSession(HttpServletRequest it, boolean a) {
 378  0
     return it.getSession(a);
 379  
   }
 380  
 
 381  
   /**
 382  
    * @param it
 383  
    *        the HttpServletRequest
 384  
    * @return      <code>true</code> if this
 385  
    *        request has an id for a valid session
 386  
    *        in the current session context;
 387  
    *        <code>false</code> otherwise
 388  
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdValid()
 389  
    * @since 2.0
 390  
    */
 391  
   public static boolean isRequestedSessionIdValid(HttpServletRequest it) {
 392  0
     return it.isRequestedSessionIdValid();
 393  
   }
 394  
 
 395  
   /**
 396  
    * @param it
 397  
    *        the HttpServletRequest
 398  
    * @return      <code>true</code> if the session ID
 399  
    *        came in as a
 400  
    *        cookie; otherwise, <code>false</code>
 401  
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromCookie()
 402  
    * @since 2.0
 403  
    */
 404  
   public static boolean isRequestedSessionIdFromCookie(HttpServletRequest it) {
 405  0
     return it.isRequestedSessionIdFromCookie();
 406  
   }
 407  
   
 408  
   //======================
 409  
   // Invocation machinery
 410  
   //======================
 411  
   
 412  
   /**
 413  
    * Thrown when a method that is not available is invoked.
 414  
    */
 415  0
   public static class MissingMethodError extends NoSuchMethodError {
 416  
     private static final long serialVersionUID = 1L;
 417  
 
 418  
     /**
 419  
      * {@inheritDoc}
 420  
      * 
 421  
      * @see java.lang.Throwable#getMessage()
 422  
      */
 423  
     public String getMessage() {
 424  0
       return "The application tried to use a method from the "
 425  
           + "Servlet API which is not present in the version it running against.";
 426  
     }
 427  
   }
 428  
 
 429  
   private static Object invoke(Method method, HttpServletRequest it,
 430  
       Object[] args) {
 431  0
     if (method == null)
 432  0
       throw new MissingMethodError();
 433  
     else {
 434  
       try {
 435  0
         return method.invoke(it, args);
 436  0
       } catch (InvocationTargetException e) {
 437  0
         Throwable f = e.getTargetException();
 438  0
         if (f instanceof RuntimeException) // they all should be
 439  0
           throw (RuntimeException)f;
 440  0
         else if (f instanceof Exception)
 441  0
           throw new RuntimeException("while invoking a Servlet API method",
 442  
                                      f);
 443  0
         else if (f instanceof Error)
 444  0
           throw (Error)f;
 445  
         else {
 446  0
           f.printStackTrace();
 447  0
           throw new Error("totally unexpected kind of throwable in "
 448  
               + "org.melati.util.servletcompat.HttpServletRequestCompat");
 449  
         }
 450  0
       } catch (IllegalAccessException e) {
 451  0
         e.printStackTrace();
 452  0
         throw new Error(
 453  
                         "org.melati.util.servletcompat.HttpServletRequestCompat"
 454  
                             + "got an unexpected IllegalAccessException trying to "
 455  
                             + "invoke a method; contact the Melati developers");
 456  
       }
 457  
     }
 458  
   }
 459  
 
 460  0
   private static final Object[] noargs = {};
 461  
 
 462  
   // 
 463  
   // ============================
 464  
   // Servlet API 2.1 deprecatons
 465  
   // ============================
 466  
   // 
 467  
 
 468  
   /**
 469  
    * @param it
 470  
    *        the HttpServletRequest
 471  
    * @param arg
 472  
    *        url String
 473  
    * @return the real path
 474  
    * @deprecated Servlet API 2.1
 475  
    * @see javax.servlet.ServletRequest#getRealPath(String)
 476  
    * @since 2.0
 477  
    */
 478  
   public static String getRealPath(HttpServletRequest it, String arg) {
 479  0
     return (String)invoke(getRealPath, it, new Object[] { arg });
 480  
   }
 481  
 
 482  
   /**
 483  
    * @param it
 484  
    *        the HttpServletRequest
 485  
    * @return whether id is from url
 486  
    * @deprecated Servlet API 2.1 
 487  
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromUrl()
 488  
    * @since 2.0
 489  
    */
 490  
   public static boolean isRequestedSessionIdFromUrl(HttpServletRequest it) {
 491  0
     return ((Boolean)invoke(isRequestedSessionIdFromUrl, it, noargs))
 492  
         .booleanValue();
 493  
   }
 494  
 
 495  
   // 
 496  
   // ============================
 497  
   // Servlet API 2.1 extensions
 498  
   // ============================
 499  
   // 
 500  
 
 501  
   /**
 502  
    * Returns the empty string when run against 2.0 API.
 503  
    * 
 504  
    * @param it
 505  
    *        the HttpServletRequest
 506  
    * @return the Context path or empty string
 507  
    * @see javax.servlet.http.HttpServletRequest#getContextPath()
 508  
    * @since 2.1
 509  
    */
 510  
   public static String getContextPath(HttpServletRequest it) {
 511  0
     if (getContextPath == null)
 512  0
       return "";
 513  
     else
 514  0
       return (String)invoke(getContextPath, it, noargs);
 515  
   }
 516  
 
 517  
   /**
 518  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
 519  
    * 
 520  
    * @param it
 521  
    *        the HttpServletRequest
 522  
    * @return    a <code>java.security.Principal</code> containing
 523  
    *      the name of the user making this request;
 524  
    *      <code>null</code> if the user has not been 
 525  
    *      authenticated
 526  
    * @see javax.servlet.http.HttpServletRequest#getUserPrincipal()
 527  
    * @since 2.1
 528  
    */
 529  
   public static java.security.Principal getUserPrincipal(HttpServletRequest it) {
 530  0
     return (java.security.Principal)invoke(getUserPrincipal, it, noargs);
 531  
   }
 532  
 
 533  
   /**
 534  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
 535  
    * 
 536  
    * @param it
 537  
    *        the HttpServletRequest
 538  
    * @param arg
 539  
    * @return      a <code>Enumeration</code> containing the
 540  
    *        values of the requested
 541  
    *        header, or <code>null</code>
 542  
    *        if the request does not
 543  
    *        have any headers of that name
 544  
    * @see javax.servlet.http.HttpServletRequest#getHeaders(java.lang.String)
 545  
    * @since 2.1
 546  
    */
 547  
   @SuppressWarnings("unchecked")
 548  
   public static Enumeration getHeaders(HttpServletRequest it, String arg) {
 549  0
     return (Enumeration)invoke(getHeaders, it, new Object[] { arg });
 550  
   }
 551  
 
 552  
   /**
 553  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API, 
 554  
    * introduced in 2.1.
 555  
    * 
 556  
    * @param it
 557  
    *        the HttpServletRequest
 558  
    * @return    the <code>HttpSession</code> associated
 559  
    *      with this request
 560  
    * @see javax.servlet.http.HttpServletRequest#getSession()
 561  
    * @since 2.1
 562  
    */
 563  
   public static HttpSession getSession(HttpServletRequest it) {
 564  0
     return (HttpSession)invoke(getSession, it, noargs);
 565  
   }
 566  
 
 567  
   /**
 568  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API, 
 569  
    * introduced in 2.1.
 570  
    * 
 571  
    * @param it
 572  
    *        the HttpServletRequest
 573  
    * @return      <code>true</code> if the session ID
 574  
    *        came in as part of a URL; otherwise,
 575  
    *        <code>false</code>
 576  
    * @see javax.servlet.http.HttpServletRequest#isRequestedSessionIdFromURL()
 577  
    * @since 2.1
 578  
    */
 579  
   public static boolean isRequestedSessionIdFromURL(HttpServletRequest it) {
 580  0
     return ((Boolean)invoke(isRequestedSessionIdFromURL, it, noargs))
 581  
         .booleanValue();
 582  
   }
 583  
 
 584  
   // 
 585  
   // ============================
 586  
   // Servlet API 2.2 extensions
 587  
   // ============================
 588  
   // 
 589  
 
 590  
   /**
 591  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API.
 592  
    * 
 593  
    * @param it
 594  
    *        the HttpServletRequest
 595  
    * @param arg
 596  
    * @return    a <code>boolean</code> indicating whether
 597  
    *      the user making this request belongs to a given role;
 598  
    *      <code>false</code> if the user has not been 
 599  
    *      authenticated
 600  
    * @see javax.servlet.http.HttpServletRequest#isUserInRole(java.lang.String)
 601  
    * @since 2.2
 602  
    */
 603  
   public static boolean isUserInRole(HttpServletRequest it, String arg) {
 604  0
     return ((Boolean)invoke(isUserInRole, it, new Object[] { arg }))
 605  
         .booleanValue();
 606  
   }
 607  
 
 608  
   /**
 609  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns an
 610  
    * <code>Enumeration</code> containing the names of the attributes available
 611  
    * to this request. This method returns an empty <code>Enumeration</code> if
 612  
    * the request has no attributes available to it.
 613  
    * 
 614  
    * @param it
 615  
    *        the HttpServletRequest
 616  
    * @return an <code>Enumeration</code> of strings containing the names of
 617  
    *         the request's attributes
 618  
    * @see javax.servlet.http.HttpServletRequest#getAttributeNames()
 619  
    * @since 2.2
 620  
    */
 621  
   @SuppressWarnings("unchecked")
 622  
   public static Enumeration getAttributeNames(HttpServletRequest it) {
 623  0
     return (Enumeration)invoke(getAttributeNames, it, noargs);
 624  
   }
 625  
 
 626  
   /**
 627  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns the
 628  
    * preferred <code>Locale</code> that the client will accept content in,
 629  
    * based on the Accept-Language header. If the client request doesn't provide
 630  
    * an Accept-Language header, this method returns the default locale for the
 631  
    * server.
 632  
    * 
 633  
    * @param it
 634  
    *        the HttpServletRequest
 635  
    * @return the preferred <code>Locale</code> for the client
 636  
    * @see javax.servlet.http.HttpServletRequest#getLocale()
 637  
    * @since 2.2
 638  
    */
 639  
   public static Locale getLocale(HttpServletRequest it) {
 640  0
     return (Locale)invoke(getLocale, it, noargs);
 641  
   }
 642  
 
 643  
   /**
 644  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns an
 645  
    * <code>Enumeration</code> of <code>Locale</code> objects indicating, in
 646  
    * decreasing order starting with the preferred locale, the locales that are
 647  
    * acceptable to the client based on the Accept-Language header. If the client
 648  
    * request doesn't provide an Accept-Language header, this method returns an
 649  
    * <code>Enumeration</code> containing one <code>Locale</code>, the
 650  
    * default locale for the server.
 651  
    * 
 652  
    * @param it
 653  
    *        the HttpServletRequest
 654  
    * @return an <code>Enumeration</code> of preferred <code>Locale</code>
 655  
    *         objects for the client
 656  
    * @see javax.servlet.http.HttpServletRequest#getLocales()
 657  
    * @since 2.2
 658  
    */
 659  
   @SuppressWarnings("unchecked")
 660  
   public static Enumeration getLocales(HttpServletRequest it) {
 661  0
     return (Enumeration)invoke(getLocales, it, noargs);
 662  
   }
 663  
 
 664  
   /**
 665  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. If you get
 666  
    * compile errors for this method, it's probably because (a) you are compiling
 667  
    * against the 2.0 servlet API.
 668  
    * 
 669  
    * Returns a {@link RequestDispatcher} object that acts as a wrapper for the
 670  
    * resource located at the given path. A <code>RequestDispatcher</code>
 671  
    * object can be used to forward a request to the resource or to include the
 672  
    * resource in a response. The resource can be dynamic or static. 
 673  
    * 
 674  
    * The
 675  
    * pathname specified may be relative, although it cannot extend outside the
 676  
    * current servlet context. If the path begins with a "/" it is interpreted as
 677  
    * relative to the current context root. This method returns <code>null</code>
 678  
    * if the servlet container cannot return a <code>RequestDispatcher</code>.
 679  
    * 
 680  
    * The difference between this method and 
 681  
    * {@link ServletContext#getRequestDispatcher} is that this method can take a
 682  
    * relative path.
 683  
    * 
 684  
    * @param it
 685  
    *        the HttpServletRequest
 686  
    * @param arg
 687  
    *        a <code>String</code> specifying the pathname to the resource
 688  
    * @return a <code>RequestDispatcher</code> object that acts as a wrapper
 689  
    *         for the resource at the specified path
 690  
    * @see RequestDispatcher
 691  
    * @see javax.servlet.http.HttpServletRequest#getRequestDispatcher(String)
 692  
    * @since 2.2
 693  
    */
 694  
   public static RequestDispatcher getRequestDispatcher(HttpServletRequest it,
 695  
       String arg) {
 696  0
     return (RequestDispatcher)invoke(getRequestDispatcher, it,
 697  
         new Object[] { arg });
 698  
   }
 699  
 
 700  
   /**
 701  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Returns a
 702  
    * boolean indicating whether this request was made using a secure channel,
 703  
    * such as HTTPS.
 704  
    * 
 705  
    * @param it
 706  
    *        the HttpServletRequest
 707  
    * @return a boolean indicating if the request was made using a secure channel
 708  
    * @see javax.servlet.http.HttpServletRequest#isSecure()
 709  
    * @since 2.2
 710  
    */
 711  
   public static boolean isSecure(HttpServletRequest it) {
 712  0
     return ((Boolean)invoke(isSecure, it, noargs)).booleanValue();
 713  
   }
 714  
 
 715  
   /**
 716  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Removes an
 717  
    * attribute from this request. This method is not generally needed as
 718  
    * attributes only persist as long as the request is being handled. <p>Attribute
 719  
    * names should follow the same conventions as package names. Names beginning
 720  
    * with <code>java.*</code>, <code>javax.*</code>, and
 721  
    * <code>com.sun.*</code>, are reserved for use by Sun Microsystems.
 722  
    * 
 723  
    * @param it
 724  
    *        the HttpServletRequest
 725  
    * @param arg
 726  
    *        a <code>String</code> specifying the name of the attribute to
 727  
    *        remove
 728  
    * @see javax.servlet.http.HttpServletRequest#removeAttribute()
 729  
    * @since 2.2
 730  
    */
 731  
   public static void removeAttribute(HttpServletRequest it, String arg) {
 732  0
     invoke(removeAttribute, it, new Object[] { arg });
 733  0
   }
 734  
 
 735  
   /**
 736  
    * Throws <TT>MissingMethodError</TT> when run against 2.0 API. Stores an
 737  
    * attribute in this request. Attributes are reset between requests. This
 738  
    * method is most often used in conjunction with {@link RequestDispatcher}.
 739  
    * <p>Attribute names should follow the same conventions as package names.
 740  
    * Names beginning with <code>java.*</code>, <code>javax.*</code>, and
 741  
    * <code>com.sun.*</code>, are reserved for use by Sun Microsystems.
 742  
    * 
 743  
    * @param it
 744  
    *        the HttpServletRequest
 745  
    * @param arg1
 746  
    *        a <code>String</code> specifying the name of the attribute
 747  
    * @param arg2
 748  
    *        the <code>Object</code> to be stored
 749  
    * @see javax.servlet.http.HttpServletRequest#setAttribute
 750  
    * @since 2.2
 751  
    */
 752  
   public static void setAttribute(HttpServletRequest it, String arg1,
 753  
       Object arg2) {
 754  0
     invoke(setAttribute, it, new Object[] { arg1, arg2 });
 755  0
   }
 756  
 
 757  
   // 
 758  
   // ============================
 759  
   // Servlet API 2.3 extensions
 760  
   // ============================
 761  
   // 
 762  
 
 763  
   /**
 764  
    * Throws <TT>MissingMethodError</TT> when run against 2.2 API.
 765  
    * 
 766  
    * @param it
 767  
    *        the HttpServletRequest
 768  
    * @return request url as a String buffer
 769  
    * @see javax.servlet.http.HttpServletRequest#getRequestURL()
 770  
    * @since 2.3
 771  
    */
 772  
   public static StringBuffer getRequestURL(HttpServletRequest it) {
 773  0
     return (StringBuffer)invoke(getRequestURL, it, noargs);
 774  
   }
 775  
 
 776  
   /**
 777  
    * Throws <TT>MissingMethodError</TT> when run against 2.2 API.
 778  
    * 
 779  
    * @param it
 780  
    *        the HttpServletRequest
 781  
    * @param arg
 782  
    *        encoding name
 783  
    * @see javax.servlet.http.HttpServletRequest#setCharacterEncoding(String)
 784  
    * @since 2.3
 785  
    */
 786  
   public static void setCharacterEncoding(HttpServletRequest it, String arg) {
 787  0
     invoke(setCharacterEncoding, it, new Object[] { arg });
 788  0
   }
 789  
 
 790  
   /**
 791  
    * @param it
 792  
    *        the HttpServletRequest
 793  
    * @return map of parameters
 794  
    * @see javax.servlet.http.HttpServletRequest#getParameterMap()
 795  
    * @since 2.3
 796  
    */
 797  
   @SuppressWarnings("unchecked")
 798  
   public static Map getParameterMap(HttpServletRequest it) {
 799  0
     return (Map)invoke(getParameterMap, it, noargs);
 800  
   }
 801  
 
 802  
 
 803  
   // 
 804  
   // ============================
 805  
   // Servlet API 2.4 extensions
 806  
   // ============================
 807  
   // 
 808  
 
 809  
   /**
 810  
    * @param it
 811  
    *        the HttpServletRequest
 812  
    * @return the remote address
 813  
    * @see javax.servlet.http.HttpServletRequest#getRemotePort()
 814  
    */
 815  
   public static int getRemotePort(HttpServletRequest it) {
 816  0
     return ((Integer)invoke(getRemotePort, it, noargs)).intValue();
 817  
   }
 818  
 
 819  
   /**
 820  
    * @param it
 821  
    *        the HttpServletRequest
 822  
    * @return the receiving local port
 823  
    * @see javax.servlet.http.HttpServletRequest#getLocalPort()
 824  
    */
 825  
   public static int getLocalPort(HttpServletRequest it) {
 826  0
     return ((Integer)invoke(getLocalPort, it, noargs)).intValue();
 827  
   }
 828  
 
 829  
   /**
 830  
    * @param it
 831  
    *        the HttpServletRequest
 832  
    * @return the local host name
 833  
    * @see javax.servlet.http.HttpServletRequest#getLocalName()
 834  
    */
 835  
   public static String getLocalName(HttpServletRequest it) {
 836  0
     return (String)invoke(getLocalName, it, noargs);    
 837  
   }
 838  
 
 839  
   /**
 840  
    * @param it
 841  
    *        the HttpServletRequest
 842  
    * @return the receiving, local, IP address
 843  
    * @see javax.servlet.http.HttpServletRequest#getLocalAddr()
 844  
    */
 845  
   public static String getLocalAddr(HttpServletRequest it) {
 846  0
     return (String)invoke(getLocalAddr, it, noargs);
 847  
   }
 848  
 
 849  
 }