001/**
002 *   GRANITE DATA SERVICES
003 *   Copyright (C) 2006-2013 GRANITE DATA SERVICES S.A.S.
004 *
005 *   This file is part of the Granite Data Services Platform.
006 *
007 *   Granite Data Services is free software; you can redistribute it and/or
008 *   modify it under the terms of the GNU Lesser General Public
009 *   License as published by the Free Software Foundation; either
010 *   version 2.1 of the License, or (at your option) any later version.
011 *
012 *   Granite Data Services is distributed in the hope that it will be useful,
013 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
014 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
015 *   General Public License for more details.
016 *
017 *   You should have received a copy of the GNU Lesser General Public
018 *   License along with this library; if not, write to the Free Software
019 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
020 *   USA, or see <http://www.gnu.org/licenses/>.
021 */
022package org.granite.util;
023
024import java.util.Enumeration;
025
026import javax.servlet.FilterConfig;
027import javax.servlet.ServletConfig;
028import javax.servlet.ServletContext;
029
030import org.granite.logging.Logger;
031
032/**
033 * @author Franck WOLFF
034 */
035public class ServletParams {
036
037        private static final Logger log = Logger.getLogger(ServletParams.class);
038
039        public static <T> T get(final ServletContext context, final String name, Class<T> clazz, T defaultValue) {
040                return get(context, name, clazz, defaultValue, false, true);
041        }
042        public static <T> T get(final ServletConfig config, final String name, Class<T> clazz, T defaultValue) {
043                return get(config, name, clazz, defaultValue, false, true);
044        }
045        public static <T> T get(final FilterConfig config, final String name, Class<T> clazz, T defaultValue) {
046                return get(config, name, clazz, defaultValue, false, true);
047        }
048
049        public static <T> T get(final ServletContext context, final String name, Class<T> clazz, T defaultValue, boolean required, boolean warn) {
050                ParamGetter getter = new ParamGetter() {
051                        
052                        public Enumeration<String> getNames() {
053                                return context.getInitParameterNames();
054                        }
055                        
056                        public String getName() {
057                                return name;
058                        }
059                        
060                        public String getValue() {
061                                return context.getInitParameter(name);
062                        }
063                };
064                return getInitParameter(getter, clazz, defaultValue, required, warn);
065        }
066
067        public static <T> T get(final ServletConfig config, final String name, Class<T> clazz, T defaultValue, boolean required, boolean warn) {
068                ParamGetter getter = new ParamGetter() {
069                        
070                        public Enumeration<String> getNames() {
071                                return config.getInitParameterNames();
072                        }
073                        
074                        public String getName() {
075                                return name;
076                        }
077                        
078                        public String getValue() {
079                                return config.getInitParameter(name);
080                        }
081                };
082                return getInitParameter(getter, clazz, defaultValue, required, warn);
083        }
084
085        public static <T> T get(final FilterConfig config, final String name, Class<T> clazz, T defaultValue, boolean required, boolean warn) {
086                ParamGetter getter = new ParamGetter() {
087                        
088                        public Enumeration<String> getNames() {
089                                return config.getInitParameterNames();
090                        }
091                        
092                        public String getName() {
093                                return name;
094                        }
095                        
096                        public String getValue() {
097                                return config.getInitParameter(name);
098                        }
099                };
100                return getInitParameter(getter, clazz, defaultValue, required, warn);
101        }
102        
103        public static boolean contains(FilterConfig config, String name) {
104                boolean found = false;
105                Enumeration<String> e = config.getInitParameterNames();
106                while (e.hasMoreElements()) {
107                        String n = e.nextElement();
108                        if (name.equals(n)) {
109                                found = true;
110                                break;
111                        }
112                }
113                return found;
114        }
115        
116        public static boolean contains(ServletConfig config, String name) {
117                boolean found = false;
118                Enumeration<String> e = config.getInitParameterNames();
119                while (e.hasMoreElements()) {
120                        String n = e.nextElement();
121                        if (name.equals(n)) {
122                                found = true;
123                                break;
124                        }
125                }
126                return found;
127        }
128        
129        public static boolean contains(ServletContext context, String name) {
130                boolean found = false;
131                Enumeration<String> e = context.getInitParameterNames();
132                while (e.hasMoreElements()) {
133                        String n = e.nextElement();
134                        if (name.equals(n)) {
135                                found = true;
136                                break;
137                        }
138                }
139                return found;
140        }
141
142        private static <T> T getInitParameter(ParamGetter getter, Class<T> clazz, T defaultValue, boolean required, boolean warn) {
143
144        if (required) {
145                boolean found = false;
146                Enumeration<String> e = getter.getNames();
147                while (e.hasMoreElements()) {
148                        String name = e.nextElement();
149                        if (name.equals(getter.getName())) {
150                                found = true;
151                                break;
152                        }
153                }
154                if (!found)
155                        throw new RuntimeException("Init parameter " + getter.getName() + " is required in web.xml");
156        }
157                
158        String sValue = getter.getValue();
159        Object oValue = defaultValue;
160        
161        boolean unsupported = false;
162        if (sValue != null) {
163                try {
164                        if (clazz == String.class)
165                                oValue = sValue;
166                        else if (clazz == Integer.class || clazz == Integer.TYPE)
167                                oValue = Integer.valueOf(sValue);
168                        else if (clazz == Long.class || clazz == Long.TYPE)
169                                oValue = Long.valueOf(sValue);
170                        else if (clazz == Boolean.class || clazz == Boolean.TYPE) {
171                                if (!Boolean.TRUE.toString().equalsIgnoreCase(sValue) && !Boolean.FALSE.toString().equalsIgnoreCase(sValue))
172                                        throw new NumberFormatException(sValue);
173                                oValue = Boolean.valueOf(sValue);
174                        }
175                        else if (clazz == Double.class || clazz == Double.TYPE)
176                                oValue = Double.valueOf(sValue);
177                        else if (clazz == Float.class || clazz == Float.TYPE)
178                                oValue = Float.valueOf(sValue);
179                        else if (clazz == Short.class || clazz == Short.TYPE)
180                                oValue = Short.valueOf(sValue);
181                        else if (clazz == Byte.class || clazz == Byte.TYPE)
182                                oValue = Byte.valueOf(sValue);
183                        else
184                                unsupported = true; 
185                }
186                catch (Exception e) {
187                        if (warn)
188                                log.warn(e, "Illegal %s value for %s: %s (using default: %s)", clazz.getSimpleName(), getter.getName(), sValue, defaultValue);
189                }
190        }
191        
192        if (unsupported)
193                throw new UnsupportedOperationException("Unsupported value type: " + clazz.getName());
194        
195        @SuppressWarnings("unchecked")
196        T tValue = (T)oValue;
197        
198        return tValue;
199    }
200        
201        private static interface ParamGetter {
202                
203                public Enumeration<String> getNames();
204                public String getName();
205                public String getValue();
206        }
207}