View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.myfaces.commons.util;
20  
21  import javax.faces.FacesException;
22  import javax.faces.context.ExternalContext;
23  
24  /**
25   * Utility class to handle web config parameters
26   * 
27   * @author Leonardo Uribe
28   * @since 1.0.1
29   */
30  public final class WebConfigParamUtils
31  {
32      public final static String[] COMMON_TRUE_VALUES = {"true", "on", "yes"};
33      public final static String[] COMMON_FALSE_VALUES = {"false", "off", "no"};
34  
35      /**
36       * Gets the String init parameter value from the specified context. If the parameter is an empty String or a String
37       * containing only white space, this method returns <code>null</code>
38       * 
39       * @param context
40       *            the application's external context
41       * @param name
42       *            the init parameter's name
43       *            
44       * @return the parameter if it was specified and was not empty, <code>null</code> otherwise
45       * 
46       * @throws NullPointerException
47       *             if context or name is <code>null</code>
48       */    
49      public static String getStringInitParameter(ExternalContext context, String name)
50      {
51          return getStringInitParameter(context,name,null);
52      }
53  
54      /**
55       * Gets the String init parameter value from the specified context. If the parameter is an empty String or a String
56       * containing only white space, this method returns <code>null</code>
57       * 
58       * @param context
59       *            the application's external context
60       * @param name
61       *            the init parameter's name
62       * @param defaultValue
63       *            the value by default if null or empty
64       *            
65       * @return the parameter if it was specified and was not empty, <code>null</code> otherwise
66       * 
67       * @throws NullPointerException
68       *             if context or name is <code>null</code>
69       */    
70      public static String getStringInitParameter(ExternalContext context, String name, String defaultValue)
71      {
72          if (name == null)
73              throw new NullPointerException();
74          
75          String param = context.getInitParameter(name);
76          
77          if (param == null)
78          {
79              return defaultValue;
80          }
81  
82          param = param.trim();
83          if (param.length() == 0)
84          {
85              return defaultValue;
86          }
87  
88          return param;
89      }
90      
91      /**
92       * Gets the String init parameter value from the specified context. If the parameter is an empty String or a String
93       * containing only white space, this method returns <code>null</code>
94       * 
95       * @param context
96       *            the application's external context
97       * @param names
98       *            the init parameter's names, the first one is scanned first. Usually used when a param has multiple aliases
99       *            
100      * @return the parameter if it was specified and was not empty, <code>null</code> otherwise
101      * 
102      * @throws NullPointerException
103      *             if context or name is <code>null</code>
104      */    
105     public static String getStringInitParameter(ExternalContext context, String[] names)
106     {
107         return getStringInitParameter(context, names, null);
108     }
109     
110     /**
111      * Gets the String init parameter value from the specified context. If the parameter is an empty String or a String
112      * containing only white space, this method returns <code>null</code>
113      * 
114      * @param context
115      *            the application's external context
116      * @param names
117      *            the init parameter's names, the first one is scanned first. Usually used when a param has multiple aliases
118      * @param defaultValue
119      *            the value by default if null or empty
120      *            
121      * @return the parameter if it was specified and was not empty, <code>null</code> otherwise
122      * 
123      * @throws NullPointerException
124      *             if context or name is <code>null</code>
125      */    
126     public static String getStringInitParameter(ExternalContext context, String[] names, String defaultValue)
127     {
128         if (names == null)
129             throw new NullPointerException();
130         
131         String param = null;
132         
133         for (String name : names)
134         {
135             if (name == null)
136                 throw new NullPointerException();
137             
138             param = context.getInitParameter(name);
139             if (param != null)
140             {
141                 break;
142             }
143         }
144         
145         if (param == null)
146         {
147             return defaultValue;
148         }
149 
150         param = param.trim();
151         if (param.length() == 0)
152         {
153             return defaultValue;
154         }
155 
156         return param;
157     }
158     
159     /**
160      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
161      * value is used instead.
162      * 
163      * @param context
164      *            the application's external context
165      * @param name
166      *            the init parameter's name
167      * @param deprecatedName
168      *            the init parameter's deprecated name.
169      * @param defaultValue
170      *            the default value to return in case the parameter was not set
171      * 
172      * @return the init parameter value as a boolean
173      * 
174      * @throws NullPointerException
175      *             if context or name is <code>null</code>
176      */
177     public static boolean getBooleanInitParameter(ExternalContext context, String name)
178     {
179         return getBooleanInitParameter(context, name, false);
180     }
181     
182     /**
183      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
184      * value is used instead.
185      * 
186      * @param context
187      *            the application's external context
188      * @param name
189      *            the init parameter's name
190      * @param deprecatedName
191      *            the init parameter's deprecated name.
192      * @param defaultValue
193      *            the default value to return in case the parameter was not set
194      * 
195      * @return the init parameter value as a boolean
196      * 
197      * @throws NullPointerException
198      *             if context or name is <code>null</code>
199      */
200     public static boolean getBooleanInitParameter(ExternalContext context, String name, boolean defaultValue)
201     {
202         if (name == null)
203             throw new NullPointerException();
204 
205         String param = getStringInitParameter(context, name);
206         if (param == null)
207         {
208             return defaultValue;
209         }
210         else
211         {
212             return Boolean.parseBoolean(param.toLowerCase());
213         }
214     }
215     
216     /**
217      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
218      * value is used instead.
219      * 
220      * @param context
221      *            the application's external context
222      * @param name
223      *            the init parameter's name
224      * @param deprecatedName
225      *            the init parameter's deprecated name.
226      * @param defaultValue
227      *            the default value to return in case the parameter was not set
228      * @param valuesIgnoreCase
229      *            an array of valid values to match
230      * @param returnOnValueEqualsIgnoreCase
231      *            the value to return in case the parameter match with valuesIgnoreCase
232      * 
233      * @return the init parameter value as a boolean
234      * 
235      * @throws NullPointerException
236      *             if context or name is <code>null</code>
237      */
238     public static boolean getBooleanInitParameter(ExternalContext context, String name, boolean defaultValue, String [] valuesIgnoreCase, boolean returnOnValueEqualsIgnoreCase)
239     {
240         if (name == null)
241             throw new NullPointerException();
242 
243         String param = getStringInitParameter(context, name);
244         if (param == null)
245         {
246             return defaultValue;
247         }
248         else
249         {
250             if (valuesIgnoreCase != null)
251             {
252                 for (String trueValue : valuesIgnoreCase)
253                 {
254                     if (trueValue.equalsIgnoreCase(param))
255                     {
256                         return returnOnValueEqualsIgnoreCase;
257                     }
258                 }
259                 return defaultValue;
260             }
261             else 
262             {
263                 return Boolean.parseBoolean(param.toLowerCase());
264             }
265         }
266     }    
267 
268     /**
269      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
270      * value is used instead.
271      * 
272      * @param context
273      *            the application's external context
274      * @param names
275      *            the init parameter's names
276      * 
277      * @return the init parameter value as a boolean
278      * 
279      * @throws NullPointerException
280      *             if context or name is <code>null</code>
281      */
282     
283     public static boolean getBooleanInitParameter(ExternalContext context, String[] names)
284     {
285         return getBooleanInitParameter(context, names, false);
286     }
287 
288     /**
289      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
290      * value is used instead.
291      * 
292      * @param context
293      *            the application's external context
294      * @param names
295      *            the init parameter's names
296      * @param defaultValue
297      *            the default value to return in case the parameter was not set
298      * 
299      * @return the init parameter value as a boolean
300      * 
301      * @throws NullPointerException
302      *             if context or name is <code>null</code>
303      */
304     public static boolean getBooleanInitParameter(ExternalContext context, String[] names, boolean defaultValue)
305     {
306         if (names == null)
307             throw new NullPointerException();
308         
309         String param = null;
310         for (String name : names)
311         {
312             if (name == null)
313                 throw new NullPointerException();
314             
315             param = getStringInitParameter(context, name);
316             if (param != null)
317             {
318                 break;
319             }
320         }
321         if (param == null)
322         {
323             return defaultValue;
324         }
325         else
326         {
327             return Boolean.parseBoolean(param.toLowerCase());
328         }
329     }
330     
331     /**
332      * Gets the boolean init parameter value from the specified context. If the parameter was not specified, the default
333      * value is used instead.
334      * 
335      * @param context
336      *            the application's external context
337      * @param names
338      *            the init parameter's names
339      * @param defaultValue
340      *            the default value to return in case the parameter was not set
341      * @param valuesIgnoreCase
342      *            an array of valid values to match
343      * @param returnOnValueEqualsIgnoreCase
344      *            the value to return in case the parameter match with valuesIgnoreCase
345      * 
346      * @return the init parameter value as a boolean
347      * 
348      * @throws NullPointerException
349      *             if context or name is <code>null</code>
350      */
351     
352     public static boolean getBooleanInitParameter(ExternalContext context, String[] names, boolean defaultValue, String [] valuesIgnoreCase, boolean returnOnValueEqualsIgnoreCase)
353     {
354         if (names == null)
355             throw new NullPointerException();
356         
357         String param = null;
358         for (String name : names)
359         {
360             if (name == null)
361                 throw new NullPointerException();
362             
363             param = getStringInitParameter(context, name);
364             if (param != null)
365             {
366                 break;
367             }
368         }
369         if (param == null)
370         {
371             return defaultValue;
372         }
373         else
374         {
375             if (valuesIgnoreCase != null)
376             {
377                 for (String trueValue : valuesIgnoreCase)
378                 {
379                     if (trueValue.equalsIgnoreCase(param))
380                     {
381                         return returnOnValueEqualsIgnoreCase;
382                     }
383                 }
384                 return defaultValue;
385             }
386             else 
387             {
388                 return Boolean.parseBoolean(param.toLowerCase());
389             }
390         }
391     }
392     
393     /**
394      * Gets the int init parameter value from the specified context. If the parameter was not specified, the default
395      * value is used instead.
396      * 
397      * @param context
398      *            the application's external context
399      * @param name
400      *            the init parameter's name
401      * @param deprecatedName
402      *            the init parameter's deprecated name.
403      * @param defaultValue
404      *            the default value to return in case the parameter was not set
405      * 
406      * @return the init parameter value as a int
407      * 
408      * @throws NullPointerException
409      *             if context or name is <code>null</code>
410      */
411     public static int getIntegerInitParameter(ExternalContext context, String name)
412     {
413         return getIntegerInitParameter(context, name, 0);
414     }
415     
416     /**
417      * Gets the int init parameter value from the specified context. If the parameter was not specified, the default
418      * value is used instead.
419      * 
420      * @param context
421      *            the application's external context
422      * @param name
423      *            the init parameter's name
424      * @param deprecatedName
425      *            the init parameter's deprecated name.
426      * @param defaultValue
427      *            the default value to return in case the parameter was not set
428      * 
429      * @return the init parameter value as a int
430      * 
431      * @throws NullPointerException
432      *             if context or name is <code>null</code>
433      */
434     public static int getIntegerInitParameter(ExternalContext context, String name, int defaultValue)
435     {
436         if (name == null)
437             throw new NullPointerException();
438 
439         String param = getStringInitParameter(context, name);
440         if (param == null)
441         {
442             return defaultValue;
443         }
444         else
445         {
446             return Integer.parseInt(param.toLowerCase());
447         }
448     }
449 
450     /**
451      * Gets the int init parameter value from the specified context. If the parameter was not specified, the default
452      * value is used instead.
453      * 
454      * @param context
455      *            the application's external context
456      * @param names
457      *            the init parameter's names
458      * 
459      * @return the init parameter value as a int
460      * 
461      * @throws NullPointerException
462      *             if context or name is <code>null</code>
463      */
464     public static int getIntegerInitParameter(ExternalContext context, String[] names)
465     {
466         return getIntegerInitParameter(context, names, 0);
467     }
468 
469     /**
470      * Gets the int init parameter value from the specified context. If the parameter was not specified, the default
471      * value is used instead.
472      * 
473      * @param context
474      *            the application's external context
475      * @param names
476      *            the init parameter's names
477      * @param defaultValue
478      *            the default value to return in case the parameter was not set
479      * 
480      * @return the init parameter value as a int
481      * 
482      * @throws NullPointerException
483      *             if context or name is <code>null</code>
484      */
485     
486     public static int getIntegerInitParameter(ExternalContext context, String[] names, int defaultValue)
487     {
488         if (names == null)
489             throw new NullPointerException();
490         
491         String param = null;
492         for (String name : names)
493         {
494             if (name == null)
495                 throw new NullPointerException();
496             
497             param = getStringInitParameter(context, name);
498             if (param != null)
499             {
500                 break;
501             }
502         }
503         if (param == null)
504         {
505             return defaultValue;
506         }
507         else
508         {
509             return Integer.parseInt(param.toLowerCase());
510         }
511     }
512     
513     /**
514      * Gets the long init parameter value from the specified context. If the parameter was not specified, the default
515      * value is used instead.
516      * 
517      * @param context
518      *            the application's external context
519      * @param name
520      *            the init parameter's name
521      * @param deprecatedName
522      *            the init parameter's deprecated name.
523      * @param defaultValue
524      *            the default value to return in case the parameter was not set
525      * 
526      * @return the init parameter value as a long
527      * 
528      * @throws NullPointerException
529      *             if context or name is <code>null</code>
530      */
531     public static long getLongInitParameter(ExternalContext context, String name)
532     {
533         return getLongInitParameter(context, name, 0);
534     }
535     
536     /**
537      * Gets the long init parameter value from the specified context. If the parameter was not specified, the default
538      * value is used instead.
539      * 
540      * @param context
541      *            the application's external context
542      * @param name
543      *            the init parameter's name
544      * @param deprecatedName
545      *            the init parameter's deprecated name.
546      * @param defaultValue
547      *            the default value to return in case the parameter was not set
548      * 
549      * @return the init parameter value as a long
550      * 
551      * @throws NullPointerException
552      *             if context or name is <code>null</code>
553      */
554     public static long getLongInitParameter(ExternalContext context, String name, long defaultValue)
555     {
556         if (name == null)
557             throw new NullPointerException();
558 
559         String param = getStringInitParameter(context, name);
560         if (param == null)
561         {
562             return defaultValue;
563         }
564         else
565         {
566             return Long.parseLong(param.toLowerCase());
567         }
568     }
569 
570     /**
571      * Gets the long init parameter value from the specified context. If the parameter was not specified, the default
572      * value is used instead.
573      * 
574      * @param context
575      *            the application's external context
576      * @param names
577      *            the init parameter's names
578      * 
579      * @return the init parameter value as a long
580      * 
581      * @throws NullPointerException
582      *             if context or name is <code>null</code>
583      */
584     
585     public static long getLongInitParameter(ExternalContext context, String[] names)
586     {
587         return getLongInitParameter(context, names, 0);
588     }
589     
590     /**
591      * Gets the long init parameter value from the specified context. If the parameter was not specified, the default
592      * value is used instead.
593      * 
594      * @param context
595      *            the application's external context
596      * @param names
597      *            the init parameter's names
598      * @param defaultValue
599      *            the default value to return in case the parameter was not set
600      * 
601      * @return the init parameter value as a long
602      * 
603      * @throws NullPointerException
604      *             if context or name is <code>null</code>
605      */
606     
607     public static long getLongInitParameter(ExternalContext context, String[] names, long defaultValue)
608     {
609         if (names == null)
610             throw new NullPointerException();
611         
612         String param = null;
613         for (String name : names)
614         {
615             if (name == null)
616                 throw new NullPointerException();
617             
618             param = getStringInitParameter(context, name);
619             if (param != null)
620             {
621                 break;
622             }
623         }
624         if (param == null)
625         {
626             return defaultValue;
627         }
628         else
629         {
630             return Long.parseLong(param.toLowerCase());
631         }
632     }
633 
634     /**
635      * Gets the init parameter value from the specified context and instanciate it. If the parameter was not specified,
636      * the default value is used instead.
637      * 
638      * @param context
639      *            the application's external context
640      * @param name
641      *            the init parameter's name
642      * @param deprecatedName
643      *            the init parameter's deprecated name.
644      * @param defaultValue
645      *            the default value to return in case the parameter was not set
646      * 
647      * @return the init parameter value as an object instance
648      * 
649      * @throws NullPointerException
650      *             if context or name is <code>null</code>
651      */
652     @SuppressWarnings("unchecked")
653     public static <T> T getInstanceInitParameter(ExternalContext context, String name, String deprecatedName, T defaultValue)
654     {
655         String param = getStringInitParameter(context, name, deprecatedName);
656         if (param == null)
657         {
658             return defaultValue;
659         }
660         else
661         {
662             try
663             {
664                 return (T) ClassUtils.classForName(param).newInstance();
665             }
666             catch (Exception e)
667             {
668                 throw new FacesException("Error Initializing Object[" + param + "]", e);
669             }
670         }
671     }
672 }