View Javadoc

    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.converters;
    19
    20  import org.apache.commons.beanutils.locale.BaseLocaleConverter;
    21  import org.apache.commons.logging.Log;
    22  import org.apache.commons.logging.LogFactory;
    23
    24  import java.math.BigDecimal;
    25  import java.math.BigInteger;
    26  import java.text.DecimalFormat;
    27  import java.text.NumberFormat;
    28  import java.text.ParseException;
    29  import java.text.SimpleDateFormat;
    30  import java.util.Date;
    31  import java.util.Locale;
    32
    33
    34  /***
    35   * <p>Standard {@link org.apache.commons.beanutils.locale.LocaleConverter}
    36   * implementation that converts an incoming
    37   * locale-sensitive object into a <code>java.lang.String</code> object,
    38   * optionally using a default value or throwing a
    39   * {@link org.apache.commons.beanutils.ConversionException}
    40   * if a conversion error occurs.</p>
    41   *
    42   * @author Yauheny Mikulski
    43   */
    44
    45  public class StringLocaleConverter extends BaseLocaleConverter {
    46
    47      // ----------------------------------------------------- Instance Variables
    48
    49      /*** All logging goes through this logger */
    50      private Log log = LogFactory.getLog(StringLocaleConverter.class);     //msz fix
    51
    52
    53      // ----------------------------------------------------------- Constructors
    54
    55      /***
    56       * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
    57       * that will throw a {@link org.apache.commons.beanutils.ConversionException}
    58       * if a conversion error occurs. The locale is the default locale for
    59       * this instance of the Java Virtual Machine and an unlocalized pattern is used
    60       * for the convertion.
    61       *
    62       */
    63      public StringLocaleConverter() {
    64
    65          this(false);
    66      }
    67
    68      /***
    69       * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
    70       * that will throw a {@link org.apache.commons.beanutils.ConversionException}
    71       * if a conversion error occurs. The locale is the default locale for
    72       * this instance of the Java Virtual Machine.
    73       *
    74       * @param locPattern    Indicate whether the pattern is localized or not
    75       */
    76      public StringLocaleConverter(boolean locPattern) {
    77
    78          this(Locale.getDefault(), locPattern);
    79      }
    80
    81      /***
    82       * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
    83       * that will throw a {@link org.apache.commons.beanutils.ConversionException}
    84       * if a conversion error occurs. An unlocalized pattern is used for the convertion.
    85       *
    86       * @param locale        The locale
    87       */
    88      public StringLocaleConverter(Locale locale) {
    89
    90          this(locale, false);
    91      }
    92
    93      /***
    94       * Create a {@link org.apache.commons.beanutils.locale.LocaleConverter}
    95       * that will throw a {@link org.apache.commons.beanutils.ConversionException}
    96       * if a conversion error occurs.
    97       *
    98       * @param locale        The locale
    99       * @param locPattern    Indicate whether the pattern is localized or not
    100      */
    101     public StringLocaleConverter(Locale locale, 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(Locale locale, 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(Locale locale, String pattern, 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(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(Object defaultValue, 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(Object defaultValue, 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(Object defaultValue, Locale locale, 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(Object defaultValue, Locale locale, 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(Object defaultValue, Locale locale, String pattern, 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      * @exception org.apache.commons.beanutils.ConversionException if conversion
    228      * cannot be performed successfully
    229      * @throws ParseException if an error occurs
    230      */
    231     protected Object parse(Object value, String pattern) throws ParseException {
    232
    233         String result = null;
    234
    235         if ((value instanceof Integer) ||
    236                 (value instanceof Long) ||
    237                 (value instanceof BigInteger) ||
    238                 (value instanceof Byte) ||
    239                 (value instanceof Short)) {
    240
    241             result = getDecimalFormat(locale, pattern).format(((Number) value).longValue());
    242         }
    243         else if ((value instanceof Double) ||
    244                 (value instanceof BigDecimal) ||
    245                 (value instanceof Float)) {
    246
    247             result = getDecimalFormat(locale, pattern).format(((Number) value).doubleValue());
    248         }
    249         else if (value instanceof Date) { // java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp
    250
    251             SimpleDateFormat dateFormat =
    252                     new SimpleDateFormat(pattern, locale);
    253
    254             result = dateFormat.format(value);
    255         }
    256         else {
    257             result = value.toString();
    258         }
    259
    260         return result;
    261     }
    262
    263     /***
    264      * Make an instance of DecimalFormat.
    265      *
    266      * @param locale The locale
    267      * @param pattern The pattern is used for the convertion
    268      * @return The format for the locale and pattern
    269      *
    270      * @exception ConversionException if conversion cannot be performed
    271      *  successfully
    272      * @throws ParseException if an error occurs parsing a String to a Number
    273      */
    274     private DecimalFormat getDecimalFormat(Locale locale, String pattern) {
    275
    276         DecimalFormat numberFormat = (DecimalFormat) NumberFormat.getInstance(locale);
    277
    278         // if some constructors default pattern to null, it makes only sense to handle null pattern gracefully
    279         if (pattern != null) {
    280             if (locPattern) {
    281                 numberFormat.applyLocalizedPattern(pattern);
    282             } else {
    283                 numberFormat.applyPattern(pattern);
    284             }
    285         } else {
    286             log.info("No pattern provided, using default.");
    287         }
    288
    289         return numberFormat;
    290     }
    291 }