1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package org.apache.commons.beanutils.locale;
19
20 import java.text.ParseException;
21 import java.util.Locale;
22
23 import org.apache.commons.beanutils.ConversionException;
24 import org.apache.commons.beanutils.ConvertUtils;
25 import org.apache.commons.logging.Log;
26 import org.apache.commons.logging.LogFactory;
27
28
29 /**
30 * <p>The base class for all standart type locale-sensitive converters.
31 * It has {@link LocaleConverter} and {@link org.apache.commons.beanutils.Converter} implementations,
32 * that convert an incoming locale-sensitive Object into an object of correspond type,
33 * optionally using a default value or throwing a {@link ConversionException}
34 * if a conversion error occurs.</p>
35 *
36 * @version $Id$
37 */
38
39 public abstract class BaseLocaleConverter implements LocaleConverter {
40
41 // ----------------------------------------------------- Instance Variables
42
43 /** All logging goes through this logger */
44 private final Log log = LogFactory.getLog(BaseLocaleConverter.class);
45
46 /** The default value specified to our Constructor, if any. */
47 private Object defaultValue = null;
48
49 /** Should we return the default value on conversion errors? */
50 protected boolean useDefault = false;
51
52 /** The locale specified to our Constructor, by default - system locale. */
53 protected Locale locale = Locale.getDefault();
54
55 /** The default pattern specified to our Constructor, if any. */
56 protected String pattern = null;
57
58 /** The flag indicating whether the given pattern string is localized or not. */
59 protected boolean locPattern = false;
60
61 // ----------------------------------------------------------- Constructors
62
63 /**
64 * Create a {@link LocaleConverter} that will throw a {@link ConversionException}
65 * if a conversion error occurs.
66 * An unlocalized pattern is used for the convertion.
67 *
68 * @param locale The locale
69 * @param pattern The convertion pattern
70 */
71 protected BaseLocaleConverter(final Locale locale, final String pattern) {
72
73 this(null, locale, pattern, false, false);
74 }
75
76 /**
77 * Create a {@link LocaleConverter} that will throw a {@link ConversionException}
78 * if a conversion error occurs.
79 *
80 * @param locale The locale
81 * @param pattern The convertion pattern
82 * @param locPattern Indicate whether the pattern is localized or not
83 */
84 protected BaseLocaleConverter(final Locale locale, final String pattern, final boolean locPattern) {
85
86 this(null, locale, pattern, false, locPattern);
87 }
88
89 /**
90 * Create a {@link LocaleConverter} that will return the specified default value
91 * if a conversion error occurs.
92 * An unlocalized pattern is used for the convertion.
93 *
94 * @param defaultValue The default value to be returned
95 * @param locale The locale
96 * @param pattern The convertion pattern
97 */
98 protected BaseLocaleConverter(final Object defaultValue, final Locale locale, final String pattern) {
99
100 this(defaultValue, locale, pattern, false);
101 }
102
103 /**
104 * Create a {@link LocaleConverter} that will return the specified default value
105 * if a conversion error occurs.
106 *
107 * @param defaultValue The default value to be returned
108 * @param locale The locale
109 * @param pattern The convertion pattern
110 * @param locPattern Indicate whether the pattern is localized or not
111 */
112 protected BaseLocaleConverter(final Object defaultValue, final Locale locale, final String pattern, final boolean locPattern) {
113
114 this(defaultValue, locale, pattern, true, locPattern);
115 }
116
117 /**
118 * Create a {@link LocaleConverter} that will return the specified default value
119 * or throw a {@link ConversionException} if a conversion error occurs.
120 *
121 * @param defaultValue The default value to be returned
122 * @param locale The locale
123 * @param pattern The convertion pattern
124 * @param useDefault Indicate whether the default value is used or not
125 * @param locPattern Indicate whether the pattern is localized or not
126 */
127 private BaseLocaleConverter(final Object defaultValue, final Locale locale,
128 final String pattern, final boolean useDefault, final boolean locPattern) {
129
130 if (useDefault) {
131 this.defaultValue = defaultValue;
132 this.useDefault = true;
133 }
134
135 if (locale != null) {
136 this.locale = locale;
137 }
138
139 this.pattern = pattern;
140 this.locPattern = locPattern;
141 }
142
143 // --------------------------------------------------------- Methods
144
145 /**
146 * Convert the specified locale-sensitive input object into an output object of the
147 * specified type.
148 *
149 * @param value The input object to be converted
150 * @param pattern The pattern is used for the convertion
151 * @return The converted value
152 *
153 * @throws ParseException if conversion cannot be performed
154 * successfully
155 */
156
157 abstract protected Object parse(Object value, String pattern) throws ParseException;
158
159
160 /**
161 * Convert the specified locale-sensitive input object into an output object.
162 * The default pattern is used for the conversion.
163 *
164 * @param value The input object to be converted
165 * @return The converted value
166 *
167 * @throws ConversionException if conversion cannot be performed
168 * successfully
169 */
170 public Object convert(final Object value) {
171 return convert(value, null);
172 }
173
174 /**
175 * Convert the specified locale-sensitive input object into an output object.
176 *
177 * @param value The input object to be converted
178 * @param pattern The pattern is used for the conversion
179 * @return The converted value
180 *
181 * @throws ConversionException if conversion cannot be performed
182 * successfully
183 */
184 public Object convert(final Object value, final String pattern) {
185 return convert(null, value, pattern);
186 }
187
188 /**
189 * Convert the specified locale-sensitive input object into an output object of the
190 * specified type. The default pattern is used for the convertion.
191 *
192 * @param <T> The desired target type of the conversion
193 * @param type Data type to which this value should be converted
194 * @param value The input object to be converted
195 * @return The converted value
196 *
197 * @throws ConversionException if conversion cannot be performed
198 * successfully
199 */
200 public <T> T convert(final Class<T> type, final Object value) {
201 return convert(type, value, null);
202 }
203
204 /**
205 * Convert the specified locale-sensitive input object into an output object of the
206 * specified type.
207 *
208 * @param <T> The desired target type of the conversion
209 * @param type Data is type to which this value should be converted
210 * @param value is the input object to be converted
211 * @param pattern is the pattern is used for the conversion; if null is
212 * passed then the default pattern associated with the converter object
213 * will be used.
214 * @return The converted value
215 *
216 * @throws ConversionException if conversion cannot be performed
217 * successfully
218 */
219 public <T> T convert(final Class<T> type, final Object value, final String pattern) {
220 final Class<T> targetType = ConvertUtils.primitiveToWrapper(type);
221 if (value == null) {
222 if (useDefault) {
223 return getDefaultAs(targetType);
224 } else {
225 // symmetric beanutils function allows null
226 // so do not: throw new ConversionException("No value specified");
227 log.debug("Null value specified for conversion, returing null");
228 return null;
229 }
230 }
231
232 try {
233 if (pattern != null) {
234 return checkConversionResult(targetType, parse(value, pattern));
235 } else {
236 return checkConversionResult(targetType, parse(value, this.pattern));
237 }
238 } catch (final Exception e) {
239 if (useDefault) {
240 return getDefaultAs(targetType);
241 } else {
242 if (e instanceof ConversionException) {
243 throw (ConversionException)e;
244 }
245 throw new ConversionException(e);
246 }
247 }
248 }
249
250 /**
251 * Returns the default object specified for this converter cast for the
252 * given target type. If the default value is not conform to the given type,
253 * an exception is thrown.
254 *
255 * @param <T> the desired target type
256 * @param type the target class of the conversion
257 * @return the default value in the given target type
258 * @throws ConversionException if the default object is not compatible with
259 * the target type
260 */
261 private <T> T getDefaultAs(final Class<T> type) {
262 return checkConversionResult(type, defaultValue);
263 }
264
265 /**
266 * Checks whether the result of a conversion is conform to the specified
267 * target type. If this is the case, the passed in result object is cast to
268 * the correct target type. Otherwise, an exception is thrown.
269 *
270 * @param <T> the desired result type
271 * @param type the target class of the conversion
272 * @param result the conversion result object
273 * @return the result cast to the target class
274 * @throws ConversionException if the result object is not compatible with
275 * the target type
276 */
277 private static <T> T checkConversionResult(final Class<T> type, final Object result) {
278 if (type == null) {
279 // in this case we cannot do much; the result object is returned
280 @SuppressWarnings("unchecked")
281 final
282 T temp = (T) result;
283 return temp;
284 }
285
286 if (result == null) {
287 return null;
288 }
289 if (type.isInstance(result)) {
290 return type.cast(result);
291 }
292 throw new ConversionException("Unsupported target type: " + type);
293 }
294 }