|
Commons Beanutils example source code file (BaseLocaleConverter.java)
The Commons Beanutils BaseLocaleConverter.java source code/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.beanutils.locale; import org.apache.commons.beanutils.ConversionException; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.text.ParseException; import java.util.Locale; /** * <p>The base class for all standart type locale-sensitive converters. * It has {@link LocaleConverter} and {@link org.apache.commons.beanutils.Converter} implementations, * that convert an incoming locale-sensitive Object into an object of correspond type, * optionally using a default value or throwing a {@link ConversionException} * if a conversion error occurs.</p> * * @author Yauheny Mikulski */ public abstract class BaseLocaleConverter implements LocaleConverter { // ----------------------------------------------------- Instance Variables /** All logging goes through this logger */ private Log log = LogFactory.getLog(BaseLocaleConverter.class); /** The default value specified to our Constructor, if any. */ private Object defaultValue = null; /** Should we return the default value on conversion errors? */ protected boolean useDefault = false; /** The locale specified to our Constructor, by default - system locale. */ protected Locale locale = Locale.getDefault(); /** The default pattern specified to our Constructor, if any. */ protected String pattern = null; /** The flag indicating whether the given pattern string is localized or not. */ protected boolean locPattern = false; // ----------------------------------------------------------- Constructors /** * Create a {@link LocaleConverter} that will throw a {@link ConversionException} * if a conversion error occurs. * An unlocalized pattern is used for the convertion. * * @param locale The locale * @param pattern The convertion pattern */ protected BaseLocaleConverter(Locale locale, String pattern) { this(null, locale, pattern, false, false); } /** * Create a {@link LocaleConverter} that will throw a {@link ConversionException} * if a conversion error occurs. * * @param locale The locale * @param pattern The convertion pattern * @param locPattern Indicate whether the pattern is localized or not */ protected BaseLocaleConverter(Locale locale, String pattern, boolean locPattern) { this(null, locale, pattern, false, locPattern); } /** * Create a {@link LocaleConverter} that will return the specified default value * if a conversion error occurs. * An unlocalized pattern is used for the convertion. * * @param defaultValue The default value to be returned * @param locale The locale * @param pattern The convertion pattern */ protected BaseLocaleConverter(Object defaultValue, Locale locale, String pattern) { this(defaultValue, locale, pattern, false); } /** * Create a {@link LocaleConverter} that will return the specified default value * if a conversion error occurs. * * @param defaultValue The default value to be returned * @param locale The locale * @param pattern The convertion pattern * @param locPattern Indicate whether the pattern is localized or not */ protected BaseLocaleConverter(Object defaultValue, Locale locale, String pattern, boolean locPattern) { this(defaultValue, locale, pattern, true, locPattern); } /** * Create a {@link LocaleConverter} that will return the specified default value * or throw a {@link ConversionException} if a conversion error occurs. * * @param defaultValue The default value to be returned * @param locale The locale * @param pattern The convertion pattern * @param useDefault Indicate whether the default value is used or not * @param locPattern Indicate whether the pattern is localized or not */ private BaseLocaleConverter(Object defaultValue, Locale locale, String pattern, boolean useDefault, boolean locPattern) { if (useDefault) { this.defaultValue = defaultValue; this.useDefault = true; } if (locale != null) { this.locale = locale; } this.pattern = pattern; this.locPattern = locPattern; } // --------------------------------------------------------- Methods /** * Convert the specified locale-sensitive input object into an output object of the * specified type. * * @param value The input object to be converted * @param pattern The pattern is used for the convertion * @return The converted value * * @exception ParseException if conversion cannot be performed * successfully */ abstract protected Object parse(Object value, String pattern) throws ParseException; /** * Convert the specified locale-sensitive input object into an output object. * The default pattern is used for the convertion. * * @param value The input object to be converted * @return The converted value * * @exception ConversionException if conversion cannot be performed * successfully */ public Object convert(Object value) { return convert(value, null); } /** * Convert the specified locale-sensitive input object into an output object. * * @param value The input object to be converted * @param pattern The pattern is used for the convertion * @return The converted value * * @exception ConversionException if conversion cannot be performed * successfully */ public Object convert(Object value, String pattern) { return convert(null, value, pattern); } /** * Convert the specified locale-sensitive input object into an output object of the * specified type. The default pattern is used for the convertion. * * @param type Data type to which this value should be converted * @param value The input object to be converted * @return The converted value * * @exception ConversionException if conversion cannot be performed * successfully */ public Object convert(Class type, Object value) { return convert(type, value, null); } /** * Convert the specified locale-sensitive input object into an output object of the * specified type. * * @param type Data is type to which this value should be converted * @param value is the input object to be converted * @param pattern is the pattern is used for the conversion; if null is * passed then the default pattern associated with the converter object * will be used. * @return The converted value * * @exception ConversionException if conversion cannot be performed * successfully */ public Object convert(Class type, Object value, String pattern) { if (value == null) { if (useDefault) { return (defaultValue); } else { // symmetric beanutils function allows null // so do not: throw new ConversionException("No value specified"); log.debug("Null value specified for conversion, returing null"); return null; } } try { if (pattern != null) { return parse(value, pattern); } else { return parse(value, this.pattern); } } catch (Exception e) { if (useDefault) { return (defaultValue); } else { if (e instanceof ConversionException) { throw (ConversionException)e; } throw new ConversionException(e); } } } } Other Commons Beanutils examples (source code examples)Here is a short list of links related to this Commons Beanutils BaseLocaleConverter.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.