Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.beanutils.locale.converters;
019
020import org.apache.commons.beanutils.locale.BaseLocaleConverter;
021import org.apache.commons.logging.Log;
022import org.apache.commons.logging.LogFactory;
023
024import java.math.BigDecimal;
025import java.math.BigInteger;
026import java.text.DecimalFormat;
027import java.text.NumberFormat;
028import java.text.ParseException;
029import java.text.SimpleDateFormat;
030import java.util.Date;
031import java.util.Locale;
032
033
034/**
035 * <p>Standard {@link org.apache.commons.beanutils.locale.LocaleConverter}
036 * implementation that converts an incoming
037 * locale-sensitive object into a <code>java.lang.String</code> object,
038 * optionally using a default value or throwing a
039 * {@link org.apache.commons.beanutils.ConversionException}
040 * if a conversion error occurs.</p>
041 *
042 * @version $Id$
043 */
044
045public class StringLocaleConverter extends BaseLocaleConverter {
046
047    // ----------------------------------------------------- Instance Variables
048
049    /** All logging goes through this logger */
050    private final Log log = LogFactory.getLog(StringLocaleConverter.class);     //msz fix
051
052
053    // ----------------------------------------------------------- Constructors
054
055    /**
056     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
057     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
058     * if a conversion error occurs. The locale is the default locale for
059     * this instance of the Java Virtual Machine and an unlocalized pattern is used
060     * for the convertion.
061     *
062     */
063    public StringLocaleConverter() {
064
065        this(false);
066    }
067
068    /**
069     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
070     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
071     * if a conversion error occurs. The locale is the default locale for
072     * this instance of the Java Virtual Machine.
073     *
074     * @param locPattern    Indicate whether the pattern is localized or not
075     */
076    public StringLocaleConverter(final boolean locPattern) {
077
078        this(Locale.getDefault(), locPattern);
079    }
080
081    /**
082     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
083     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
084     * if a conversion error occurs. An unlocalized pattern is used for the convertion.
085     *
086     * @param locale        The locale
087     */
088    public StringLocaleConverter(final Locale locale) {
089
090        this(locale, false);
091    }
092
093    /**
094     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
095     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
096     * if a conversion error occurs.
097     *
098     * @param locale        The locale
099     * @param locPattern    Indicate whether the pattern is localized or not
100     */
101    public StringLocaleConverter(final Locale locale, final boolean locPattern) {
102
103        this(locale, (String) null, locPattern);
104    }
105
106    /**
107     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
108     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
109     * if a conversion error occurs. An unlocalized pattern is used for the convertion.
110     *
111     * @param locale        The locale
112     * @param pattern       The convertion pattern
113     */
114    public StringLocaleConverter(final Locale locale, final String pattern) {
115
116        this(locale, pattern, false);
117    }
118
119    /**
120     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
121     * that will throw a {@link org.apache.commons.beanutils.ConversionException}
122     * if a conversion error occurs.
123     *
124     * @param locale        The locale
125     * @param pattern       The convertion pattern
126     * @param locPattern    Indicate whether the pattern is localized or not
127     */
128    public StringLocaleConverter(final Locale locale, final String pattern, final boolean locPattern) {
129
130        super(locale, pattern, locPattern);
131    }
132
133    /**
134     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
135     * that will return the specified default value
136     * if a conversion error occurs. The locale is the default locale for
137     * this instance of the Java Virtual Machine and an unlocalized pattern is used
138     * for the convertion.
139     *
140     * @param defaultValue  The default value to be returned
141     */
142    public StringLocaleConverter(final Object defaultValue) {
143
144        this(defaultValue, false);
145    }
146
147    /**
148     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
149     * that will return the specified default value
150     * if a conversion error occurs. The locale is the default locale for
151     * this instance of the Java Virtual Machine.
152     *
153     * @param defaultValue  The default value to be returned
154     * @param locPattern    Indicate whether the pattern is localized or not
155     */
156    public StringLocaleConverter(final Object defaultValue, final boolean locPattern) {
157
158        this(defaultValue, Locale.getDefault(), locPattern);
159    }
160
161    /**
162     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
163     * that will return the specified default value
164     * if a conversion error occurs. An unlocalized pattern is used for the convertion.
165     *
166     * @param defaultValue  The default value to be returned
167     * @param locale        The locale
168     */
169    public StringLocaleConverter(final Object defaultValue, final Locale locale) {
170
171        this(defaultValue, locale, false);
172    }
173
174    /**
175     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
176     * that will return the specified default value
177     * if a conversion error occurs.
178     *
179     * @param defaultValue  The default value to be returned
180     * @param locale        The locale
181     * @param locPattern    Indicate whether the pattern is localized or not
182     */
183    public StringLocaleConverter(final Object defaultValue, final Locale locale, final boolean locPattern) {
184
185        this(defaultValue, locale, null, locPattern);
186    }
187
188    /**
189     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
190     * that will return the specified default value
191     * if a conversion error occurs. An unlocalized pattern is used for the convertion.
192     *
193     * @param defaultValue  The default value to be returned
194     * @param locale        The locale
195     * @param pattern       The convertion pattern
196     */
197    public StringLocaleConverter(final Object defaultValue, final Locale locale, final String pattern) {
198
199        this(defaultValue, locale, pattern, false);
200    }
201
202    /**
203     * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
204     * that will return the specified default value
205     * if a conversion error occurs.
206     *
207     * @param defaultValue  The default value to be returned
208     * @param locale        The locale
209     * @param pattern       The convertion pattern
210     * @param locPattern    Indicate whether the pattern is localized or not
211     */
212    public StringLocaleConverter(final Object defaultValue, final Locale locale, final String pattern, final boolean locPattern) {
213
214        super(defaultValue, locale, pattern, locPattern);
215    }
216
217    // --------------------------------------------------------- Methods
218
219    /**
220     * Convert the specified locale-sensitive input object into an output object of the
221     * specified type.
222     *
223     * @param value The input object to be converted
224     * @param pattern The pattern is used for the convertion
225     * @return The converted value
226     *
227     * @throws org.apache.commons.beanutils.ConversionException if conversion
228     * cannot be performed successfully
229     * @throws ParseException if an error occurs
230     */
231    @Override
232    protected Object parse(final Object value, final String pattern) throws ParseException {
233
234        String result = null;
235
236        if ((value instanceof Integer) ||
237                (value instanceof Long) ||
238                (value instanceof BigInteger) ||
239                (value instanceof Byte) ||
240                (value instanceof Short)) {
241
242            result = getDecimalFormat(locale, pattern).format(((Number) value).longValue());
243        }
244        else if ((value instanceof Double) ||
245                (value instanceof BigDecimal) ||
246                (value instanceof Float)) {
247
248            result = getDecimalFormat(locale, pattern).format(((Number) value).doubleValue());
249        }
250        else if (value instanceof Date) { // java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp
251
252            final SimpleDateFormat dateFormat =
253                    new SimpleDateFormat(pattern, locale);
254
255            result = dateFormat.format(value);
256        }
257        else {
258            result = value.toString();
259        }
260
261        return result;
262    }
263
264    /**
265     * Make an instance of DecimalFormat.
266     *
267     * @param locale The locale
268     * @param pattern The pattern is used for the convertion
269     * @return The format for the locale and pattern
270     *
271     * @throws ConversionException if conversion cannot be performed
272     *  successfully
273     * @throws ParseException if an error occurs parsing a String to a Number
274     */
275    private DecimalFormat getDecimalFormat(final Locale locale, final String pattern) {
276
277        final DecimalFormat numberFormat = (DecimalFormat) NumberFormat.getInstance(locale);
278
279        // if some constructors default pattern to null, it makes only sense to handle null pattern gracefully
280        if (pattern != null) {
281            if (locPattern) {
282                numberFormat.applyLocalizedPattern(pattern);
283            } else {
284                numberFormat.applyPattern(pattern);
285            }
286        } else {
287            log.debug("No pattern provided, using default.");
288        }
289
290        return numberFormat;
291    }
292}