/*
* 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.cocoon.template.instruction;
import java.lang.reflect.Method;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.util.Locale;
import java.util.Stack;
import org.apache.cocoon.components.expression.ExpressionContext;
import org.apache.cocoon.template.environment.ErrorHolder;
import org.apache.cocoon.template.environment.ExecutionContext;
import org.apache.cocoon.template.environment.ParsingContext;
import org.apache.cocoon.template.expression.JXTExpression;
import org.apache.cocoon.template.expression.StringTemplateParser;
import org.apache.cocoon.template.script.event.Event;
import org.apache.cocoon.template.script.event.StartElement;
import org.apache.cocoon.xml.XMLConsumer;
import org.apache.commons.lang.StringUtils;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
/**
* @version SVN $Id$
*/
public class FormatNumber extends LocaleAwareInstruction {
private JXTExpression value;
private JXTExpression type;
private JXTExpression pattern;
private JXTExpression currencyCode;
private JXTExpression currencySymbol;
private JXTExpression isGroupingUsed;
private JXTExpression maxIntegerDigits;
private JXTExpression minIntegerDigits;
private JXTExpression maxFractionDigits;
private JXTExpression minFractionDigits;
private JXTExpression var;
private static Class currencyClass;
private static final String NUMBER = "number";
private static final String CURRENCY = "currency";
private static final String PERCENT = "percent";
static {
try {
currencyClass = Class.forName("java.util.Currency");
// container's runtime is J2SE 1.4 or greater
} catch (Exception cnfe) {
// EMPTY
}
}
public FormatNumber(ParsingContext parsingContext, StartElement raw, Attributes attrs, Stack stack)
throws SAXException {
super(parsingContext, raw, attrs, stack);
Locator locator = getLocation();
StringTemplateParser expressionCompiler = parsingContext.getStringTemplateParser();
this.value = expressionCompiler.compileExpr(attrs.getValue("value"), null, locator);
this.type = expressionCompiler.compileExpr(attrs.getValue("type"), null, locator);
this.pattern = expressionCompiler.compileExpr(attrs.getValue("pattern"), null, locator);
this.currencyCode =
expressionCompiler.compileExpr(attrs.getValue("currencyCode"), null, locator);
this.currencySymbol =
expressionCompiler.compileExpr(attrs.getValue("currencySymbol"), null, locator);
this.isGroupingUsed =
expressionCompiler.compileBoolean(attrs.getValue("isGroupingUsed"), null, locator);
this.maxIntegerDigits =
expressionCompiler.compileInt(attrs.getValue("maxIntegerDigits"), null, locator);
this.minIntegerDigits =
expressionCompiler.compileInt(attrs.getValue("minIntegerDigits"), null, locator);
this.maxFractionDigits =
expressionCompiler.compileInt(attrs.getValue("maxFractionDigits"), null, locator);
this.minFractionDigits =
expressionCompiler.compileInt(attrs.getValue("minFractionDigits"), null, locator);
this.var = expressionCompiler.compileExpr(attrs.getValue("var"), null, locator);
}
public Event execute(final XMLConsumer consumer,
ExpressionContext expressionContext, ExecutionContext executionContext,
MacroContext macroContext, Event startEvent, Event endEvent)
throws SAXException {
try {
String result = format(expressionContext);
if (result != null) {
char[] chars = result.toCharArray();
consumer.characters(chars, 0, chars.length);
}
} catch (Exception e) {
throw new SAXParseException(e.getMessage(), getLocation(), e);
} catch (Error err) {
throw new SAXParseException(err.getMessage(), getLocation(),
new ErrorHolder(err));
}
return getNext();
}
private String format(ExpressionContext expressionContext) throws Exception {
// Determine formatting locale
String var = this.var == null ? null : this.var.getStringValue(expressionContext);
Number input = this.value.getNumberValue(expressionContext);
String type = this.type == null ? null : this.type.getStringValue(expressionContext);
String pattern = this.pattern == null ? null : this.pattern.getStringValue(expressionContext);
String currencyCode = this.currencyCode == null ? null : this.currencyCode.getStringValue(expressionContext);
String currencySymbol = this.currencySymbol == null ? null : this.currencySymbol.getStringValue(expressionContext);
Boolean isGroupingUsed = this.isGroupingUsed == null ? null : this.isGroupingUsed.getBooleanValue(expressionContext);
Number maxIntegerDigits = this.maxIntegerDigits == null ? null : this.maxIntegerDigits.getNumberValue(expressionContext);
Number minIntegerDigits = this.minIntegerDigits == null ? null : this.minIntegerDigits.getNumberValue(expressionContext);
Number maxFractionDigits = this.maxFractionDigits == null ? null : this.maxFractionDigits.getNumberValue(expressionContext);
Number minFractionDigits = this.minFractionDigits == null ? null : this.minFractionDigits.getNumberValue(expressionContext);
Locale loc = getLocale(expressionContext);
String formatted;
if (loc != null) {
// Create formatter
NumberFormat formatter = null;
if (StringUtils.isNotEmpty(pattern)) {
// if 'pattern' is specified, 'type' is ignored
DecimalFormatSymbols symbols = new DecimalFormatSymbols(loc);
formatter = new DecimalFormat(pattern, symbols);
} else {
formatter = createFormatter(loc, type);
}
if (StringUtils.isNotEmpty(pattern)
|| CURRENCY.equalsIgnoreCase(type)) {
setCurrency(formatter, currencyCode, currencySymbol);
}
configureFormatter(formatter, isGroupingUsed, maxIntegerDigits,
minIntegerDigits, maxFractionDigits, minFractionDigits);
formatted = formatter.format(input);
} else {
// no formatting locale available, use toString()
formatted = input.toString();
}
if (var != null) {
expressionContext.put(var, formatted);
return null;
}
return formatted;
}
private NumberFormat createFormatter(Locale loc, String type)
throws Exception {
NumberFormat formatter = null;
if ((type == null) || NUMBER.equalsIgnoreCase(type)) {
formatter = NumberFormat.getNumberInstance(loc);
} else if (CURRENCY.equalsIgnoreCase(type)) {
formatter = NumberFormat.getCurrencyInstance(loc);
} else if (PERCENT.equalsIgnoreCase(type)) {
formatter = NumberFormat.getPercentInstance(loc);
} else {
throw new IllegalArgumentException("Invalid type: \"" + type
+ "\": should be \"number\" or \"currency\" or \"percent\"");
}
return formatter;
}
/*
* Applies the 'groupingUsed', 'maxIntegerDigits', 'minIntegerDigits',
* 'maxFractionDigits', and 'minFractionDigits' attributes to the given
* formatter.
*/
private void configureFormatter(NumberFormat formatter,
Boolean isGroupingUsed, Number maxIntegerDigits,
Number minIntegerDigits, Number maxFractionDigits,
Number minFractionDigits) {
if (isGroupingUsed != null)
formatter.setGroupingUsed(isGroupingUsed.booleanValue());
if (maxIntegerDigits != null)
formatter.setMaximumIntegerDigits(maxIntegerDigits.intValue());
if (minIntegerDigits != null)
formatter.setMinimumIntegerDigits(minIntegerDigits.intValue());
if (maxFractionDigits != null)
formatter.setMaximumFractionDigits(maxFractionDigits.intValue());
if (minFractionDigits != null)
formatter.setMinimumFractionDigits(minFractionDigits.intValue());
}
/*
* Override the formatting locale's default currency symbol with the
* specified currency code (specified via the "currencyCode" attribute) or
* currency symbol (specified via the "currencySymbol" attribute).
*
* If both "currencyCode" and "currencySymbol" are present, "currencyCode"
* takes precedence over "currencySymbol" if the java.util.Currency class is
* defined in the container's runtime (that is, if the container's runtime
* is J2SE 1.4 or greater), and "currencySymbol" takes precendence over
* "currencyCode" otherwise.
*
* If only "currencyCode" is given, it is used as a currency symbol if
* java.util.Currency is not defined.
*
* Example:
*
* JDK "currencyCode" "currencySymbol" Currency symbol being displayed
* -----------------------------------------------------------------------
* all --- --- Locale's default currency symbol
*
* <1.4 EUR --- EUR >=1.4 EUR --- Locale's currency symbol for Euro
*
* all --- \u20AC \u20AC
*
* <1.4 EUR \u20AC \u20AC >=1.4 EUR \u20AC Locale's currency symbol for Euro
*/
private void setCurrency(NumberFormat formatter, String currencyCode,
String currencySymbol) throws Exception {
String code = null;
String symbol = null;
if (currencyCode == null) {
if (currencySymbol == null) {
return;
}
symbol = currencySymbol;
} else if (currencySymbol != null) {
if (currencyClass != null) {
code = currencyCode;
} else {
symbol = currencySymbol;
}
} else if (currencyClass != null) {
code = currencyCode;
} else {
symbol = currencyCode;
}
if (code != null) {
Object[] methodArgs = new Object[1];
/*
* java.util.Currency.getInstance()
*/
Method m = currencyClass.getMethod("getInstance",
new Class[] { String.class });
methodArgs[0] = code;
Object currency = m.invoke(null, methodArgs);
/*
* java.text.NumberFormat.setCurrency()
*/
Class[] paramTypes = new Class[1];
paramTypes[0] = currencyClass;
Class numberFormatClass = Class.forName("java.text.NumberFormat");
m = numberFormatClass.getMethod("setCurrency", paramTypes);
methodArgs[0] = currency;
m.invoke(formatter, methodArgs);
} else {
/*
* Let potential ClassCastException propagate up (will almost never
* happen)
*/
DecimalFormat df = (DecimalFormat) formatter;
DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();
dfs.setCurrencySymbol(symbol);
df.setDecimalFormatSymbols(dfs);
}
}
}