/**
* Standard {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter}
* implementation that converts an incoming locale-sensitive String into a <code>java.lang.Decimal
* </code> object, optionally using a default value or throwing a {@link
* com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion error occurs.
*
* @author Yauheny Mikulski
* @author Yoav Shapira
* @since 1.7
*/
public class DecimalLocaleConverter extends BaseLocaleConverter {
// ----------------------------------------------------- Instance Variables
/** All logging goes through this logger */
private static Log log = LogFactory.getLog(DecimalLocaleConverter.class);
// ----------------------------------------------------------- Constructors
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion
* error occurs. The locale is the default locale for this instance of the Java Virtual Machine
* and an unlocalized pattern is used for the convertion.
*/
public DecimalLocaleConverter() {
this(false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion
* error occurs. The locale is the default locale for this instance of the Java Virtual Machine.
*
* @param locPattern Indicate whether the pattern is localized or not
*/
public DecimalLocaleConverter(boolean locPattern) {
this(Locale.getDefault(), locPattern);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion
* error occurs. An unlocalized pattern is used for the convertion.
*
* @param locale The locale
*/
public DecimalLocaleConverter(Locale locale) {
this(locale, false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion
* error occurs.
*
* @param locale The locale
* @param locPattern Indicate whether the pattern is localized or not
*/
public DecimalLocaleConverter(Locale locale, boolean locPattern) {
this(locale, (String) null, locPattern);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.ConversionException} if a conversion
* error occurs. An unlocalized pattern is used for the convertion.
*
* @param locale The locale
* @param pattern The convertion pattern
*/
public DecimalLocaleConverter(Locale locale, String pattern) {
this(locale, pattern, false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* throw a {@link com.usemon.lib.org.apache.commons.beanutils.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
*/
public DecimalLocaleConverter(Locale locale, String pattern, boolean locPattern) {
this(null, locale, pattern, locPattern);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* return the specified default value if a conversion error occurs. The locale is the default
* locale for this instance of the Java Virtual Machine and an unlocalized pattern is used for the
* convertion.
*
* @param defaultValue The default value to be returned
*/
public DecimalLocaleConverter(Object defaultValue) {
this(defaultValue, false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.LocaleConverter} that will
* return the specified default value if a conversion error occurs. The locale is the default
* locale for this instance of the Java Virtual Machine.
*
* @param defaultValue The default value to be returned
* @param locPattern Indicate whether the pattern is localized or not
*/
public DecimalLocaleConverter(Object defaultValue, boolean locPattern) {
this(defaultValue, Locale.getDefault(), locPattern);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.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
*/
public DecimalLocaleConverter(Object defaultValue, Locale locale) {
this(defaultValue, locale, false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.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 locPattern Indicate whether the pattern is localized or not
*/
public DecimalLocaleConverter(Object defaultValue, Locale locale, boolean locPattern) {
this(defaultValue, locale, null, locPattern);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.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
*/
public DecimalLocaleConverter(Object defaultValue, Locale locale, String pattern) {
this(defaultValue, locale, pattern, false);
}
/**
* Create a {@link com.usemon.lib.org.apache.commons.beanutils.locale.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
*/
public DecimalLocaleConverter(
Object defaultValue, Locale locale, String pattern, boolean locPattern) {
super(defaultValue, locale, pattern, 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
* @exception ConversionException if conversion cannot be performed successfully
*/
protected Object parse(Object value, String pattern) throws ParseException {
// DecimalFormat is not thread safe so best to construct one each time
DecimalFormat formatter = (DecimalFormat) DecimalFormat.getInstance(locale);
// if some constructors default pattern to null, it makes only sense to handle null pattern
// gracefully
if (pattern != null) {
if (locPattern) {
formatter.applyLocalizedPattern(pattern);
} else {
formatter.applyPattern(pattern);
}
} else {
log.warn("No pattern provided, using default.");
}
return formatter.parse((String) value);
}
}
/**
* Create a <code>SAXParser</code> based on the underlying Xerces version. Currently, Xerces 2.3 and
* up doesn't implement schema validation the same way 2.1 was. In other to support schema
* validation in a portable way between parser, some features/properties need to be set.
*
* @since 1.6
*/
public class XercesParser {
/** The Log to which all SAX event related logging calls will be made. */
protected static Log log = LogFactory.getLog("org.apache.commons.digester.Digester.sax");
/** The JAXP 1.2 property required to set up the schema location. */
private static final String JAXP_SCHEMA_SOURCE =
"http://java.sun.com/xml/jaxp/properties/schemaSource";
/** The JAXP 1.2 property to set up the schemaLanguage used. */
protected static String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/** Xerces dynamic validation property */
protected static String XERCES_DYNAMIC = "http://apache.org/xml/features/validation/dynamic";
/** Xerces schema validation property */
protected static String XERCES_SCHEMA = "http://apache.org/xml/features/validation/schema";
/** A <code>float</code> representing the underlying Xerces version */
protected static float version;
/** The current Xerces version. */
protected static String versionNumber = null;
/**
* Return the current Xerces version.
*
* @return the current Xerces version.
*/
private static String getXercesVersion() {
// If for some reason we can't get the version, set it to 1.0.
String versionNumber = "1.0";
try {
// Use reflection to avoid a build dependency with Xerces.
Class versionClass = Class.forName("org.apache.xerces.impl.Version");
// Will return Xerces-J 2.x.0
Method method = versionClass.getMethod("getVersion", (Class[]) null);
String version = (String) method.invoke(null, (Object[]) null);
versionNumber = version.substring("Xerces-J".length(), version.lastIndexOf("."));
} catch (Exception ex) {
// Do nothing.
}
return versionNumber;
}
/**
* Create a <code>SAXParser</code> based on the underlying <code>Xerces</code> version.
*
* @param properties parser specific properties/features
* @return an XML Schema/DTD enabled <code>SAXParser</code>
*/
public static SAXParser newSAXParser(Properties properties)
throws ParserConfigurationException, SAXException, SAXNotSupportedException {
SAXParserFactory factory = (SAXParserFactory) properties.get("SAXParserFactory");
if (versionNumber == null) {
versionNumber = getXercesVersion();
version = new Float(versionNumber).floatValue();
}
// Note: 2.2 is completely broken (with XML Schema).
if (version > 2.1) {
configureXerces(factory);
return factory.newSAXParser();
} else {
SAXParser parser = factory.newSAXParser();
configureOldXerces(parser, properties);
return parser;
}
}
/**
* Configure schema validation as recommended by the JAXP 1.2 spec. The <code>properties</code>
* object may contains information about the schema local and language.
*
* @param properties parser optional info
*/
private static void configureOldXerces(SAXParser parser, Properties properties)
throws ParserConfigurationException, SAXNotSupportedException {
String schemaLocation = (String) properties.get("schemaLocation");
String schemaLanguage = (String) properties.get("schemaLanguage");
try {
if (schemaLocation != null) {
parser.setProperty(JAXP_SCHEMA_LANGUAGE, schemaLanguage);
parser.setProperty(JAXP_SCHEMA_SOURCE, schemaLocation);
}
} catch (SAXNotRecognizedException e) {
log.info(parser.getClass().getName() + ": " + e.getMessage() + " not supported.");
}
}
/**
* Configure schema validation as recommended by the Xerces spec. Both DTD and Schema validation
* will be enabled simultaneously.
*
* <p>NOTE: This method is broken. It is supposed to set up validation against the schema
* specified in property "schemaLocation", but it doesn't.
*
* @param factory SAXParserFactory to be configured
*/
private static void configureXerces(SAXParserFactory factory)
throws ParserConfigurationException, SAXNotRecognizedException, SAXNotSupportedException {
factory.setFeature(XERCES_DYNAMIC, true);
factory.setFeature(XERCES_SCHEMA, true);
}
}