Coverage Report

##### Coverage Report - org.melati.util.HttpServletRequestCompat

Classes in this File | Line Coverage | Branch Coverage | Complexity
HttpServletRequestCompat |
0% | 0/94
0% | 0/12
| 1.4651162790697674;1.465
HttpServletRequestCompat$MissingMethodError |
0% | 0/2
N/A | N/A
| 1.4651162790697674;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 |  |
     }