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;
    19
    20  import org.apache.commons.beanutils.ConversionException;
    21  import org.apache.commons.logging.Log;
    22  import org.apache.commons.logging.LogFactory;
    23
    24  import java.text.ParseException;
    25  import java.util.Locale;
    26
    27
    28  /***
    29   * <p>The base class for all standart type locale-sensitive converters.
    30   * It has {@link LocaleConverter} and {@link org.apache.commons.beanutils.Converter} implementations,
    31   * that convert an incoming locale-sensitive Object into an object of correspond type,
    32   * optionally using a default value or throwing a {@link ConversionException}
    33   * if a conversion error occurs.</p>
    34   *
    35   * @author Yauheny Mikulski
    36   */
    37
    38  public abstract class BaseLocaleConverter implements LocaleConverter {
    39
    40      // ----------------------------------------------------- Instance Variables
    41
    42      /*** All logging goes through this logger */
    43      private Log log = LogFactory.getLog(BaseLocaleConverter.class);
    44
    45      /*** The default value specified to our Constructor, if any. */
    46      private Object defaultValue = null;
    47
    48      /*** Should we return the default value on conversion errors? */
    49      protected boolean useDefault = false;
    50
    51      /*** The locale specified to our Constructor, by default - system locale. */
    52      protected Locale locale = Locale.getDefault();
    53
    54      /*** The default pattern specified to our Constructor, if any. */
    55      protected String pattern = null;
    56
    57      /*** The flag indicating whether the given pattern string is localized or not. */
    58      protected boolean locPattern = false;
    59
    60      // ----------------------------------------------------------- Constructors
    61
    62      /***
    63       * Create a {@link LocaleConverter} that will throw a {@link ConversionException}
    64       * if a conversion error occurs.
    65       * An unlocalized pattern is used for the convertion.
    66       *
    67       * @param locale        The locale
    68       * @param pattern       The convertion pattern
    69       */
    70      protected BaseLocaleConverter(Locale locale, String pattern) {
    71
    72          this(null, locale, pattern, false, false);
    73      }
    74
    75      /***
    76       * Create a {@link LocaleConverter} that will throw a {@link ConversionException}
    77       * if a conversion error occurs.
    78       *
    79       * @param locale        The locale
    80       * @param pattern       The convertion pattern
    81       * @param locPattern    Indicate whether the pattern is localized or not
    82       */
    83      protected BaseLocaleConverter(Locale locale, String pattern, boolean locPattern) {
    84
    85          this(null, locale, pattern, false, locPattern);
    86      }
    87
    88      /***
    89       * Create a {@link LocaleConverter} that will return the specified default value
    90       * if a conversion error occurs.
    91       * An unlocalized pattern is used for the convertion.
    92       *
    93       * @param defaultValue  The default value to be returned
    94       * @param locale        The locale
    95       * @param pattern       The convertion pattern
    96       */
    97      protected BaseLocaleConverter(Object defaultValue, Locale locale, String pattern) {
    98
    99          this(defaultValue, locale, pattern, false);
    100     }
    101
    102     /***
    103      * Create a {@link LocaleConverter} that will return the specified default value
    104      * if a conversion error occurs.
    105      *
    106      * @param defaultValue  The default value to be returned
    107      * @param locale        The locale
    108      * @param pattern       The convertion pattern
    109      * @param locPattern    Indicate whether the pattern is localized or not
    110      */
    111     protected BaseLocaleConverter(Object defaultValue, Locale locale, String pattern, boolean locPattern) {
    112
    113         this(defaultValue, locale, pattern, true, locPattern);
    114     }
    115
    116     /***
    117      * Create a {@link LocaleConverter} that will return the specified default value
    118      * or throw a {@link ConversionException} if a conversion error occurs.
    119      *
    120      * @param defaultValue  The default value to be returned
    121      * @param locale        The locale
    122      * @param pattern       The convertion pattern
    123      * @param useDefault    Indicate whether the default value is used or not
    124      * @param locPattern    Indicate whether the pattern is localized or not
    125      */
    126     private BaseLocaleConverter(Object defaultValue, Locale locale,
    127                                 String pattern, boolean useDefault, boolean locPattern) {
    128
    129         if (useDefault) {
    130             this.defaultValue = defaultValue;
    131             this.useDefault = true;
    132         }
    133
    134         if (locale != null) {
    135             this.locale = locale;
    136         }
    137
    138         this.pattern = pattern;
    139         this.locPattern = locPattern;
    140     }
    141
    142     // --------------------------------------------------------- Methods
    143
    144     /***
    145      * Convert the specified locale-sensitive input object into an output object of the
    146      * specified type.
    147      *
    148      * @param value The input object to be converted
    149      * @param pattern The pattern is used for the convertion
    150      * @return The converted value
    151      *
    152      * @exception ParseException if conversion cannot be performed
    153      *  successfully
    154      */
    155
    156     abstract protected Object parse(Object value, String pattern) throws ParseException;
    157
    158
    159     /***
    160      * Convert the specified locale-sensitive input object into an output object.
    161      * The default pattern is used for the convertion.
    162      *
    163      * @param value The input object to be converted
    164      * @return The converted value
    165      *
    166      * @exception ConversionException if conversion cannot be performed
    167      *  successfully
    168      */
    169     public Object convert(Object value) {
    170         return convert(value, null);
    171     }
    172
    173     /***
    174      * Convert the specified locale-sensitive input object into an output object.
    175      *
    176      * @param value The input object to be converted
    177      * @param pattern The pattern is used for the convertion
    178      * @return The converted value
    179      *
    180      * @exception ConversionException if conversion cannot be performed
    181      *  successfully
    182      */
    183     public Object convert(Object value, String pattern) {
    184         return convert(null, value, pattern);
    185     }
    186
    187     /***
    188      * Convert the specified locale-sensitive input object into an output object of the
    189      * specified type. The default pattern is used for the convertion.
    190      *
    191      * @param type Data type to which this value should be converted
    192      * @param value The input object to be converted
    193      * @return The converted value
    194      *
    195      * @exception ConversionException if conversion cannot be performed
    196      *  successfully
    197      */
    198     public Object convert(Class type, Object value) {
    199         return convert(type, value, null);
    200     }
    201
    202     /***
    203      * Convert the specified locale-sensitive input object into an output object of the
    204      * specified type.
    205      *
    206      * @param type Data is type to which this value should be converted
    207      * @param value is the input object to be converted
    208      * @param pattern is the pattern is used for the conversion; if null is
    209      * passed then the default pattern associated with the converter object
    210      * will be used.
    211      * @return The converted value
    212      *
    213      * @exception ConversionException if conversion cannot be performed
    214      *  successfully
    215      */
    216     public Object convert(Class type, Object value, String pattern) {
    217         if (value == null) {
    218             if (useDefault) {
    219                 return (defaultValue);
    220             } else {
    221                 // symmetric beanutils function allows null
    222                 // so do not: throw new ConversionException("No value specified");
    223                 log.debug("Null value specified for conversion, returing null");
    224                 return null;
    225             }
    226         }
    227
    228         try {
    229             if (pattern != null) {
    230                 return parse(value, pattern);
    231             } else {
    232                 return parse(value, this.pattern);
    233             }
    234         } catch (Exception e) {
    235             if (useDefault) {
    236                 return (defaultValue);
    237             } else {
    238                 if (e instanceof ConversionException) {
    239                     throw (ConversionException)e;
    240                 }
    241                 throw new ConversionException(e);
    242             }
    243         }
    244     }
    245 }