coliver 2003/08/08 11:49:06
Modified: src/documentation/xdocs/userdocs/flow jxtemplate.xml
src/java/org/apache/cocoon/generation
JXTemplateGenerator.java
Log:
Added JSTL formatNumber and formatDate tags
Revision Changes Path
1.18 +60 -1 cocoon-2.1/src/documentation/xdocs/userdocs/flow/jxtemplate.xml
Index: jxtemplate.xml
===================================================================
RCS file: /home/cvs/cocoon-2.1/src/documentation/xdocs/userdocs/flow/jxtemplate.xml,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- jxtemplate.xml 20 Jul 2003 05:48:18 -0000 1.17
+++ jxtemplate.xml 8 Aug 2003 18:49:06 -0000 1.18
@@ -233,12 +233,71 @@
</source>
<p/>
</s2>
+<s2 title="formatNumber">
+<p>
+The <code>formatNumber</code> tag is used to display numeric data, including
currencies and percentages, in a locale-specific manner. It determines from the
locale, for example, whether to use a period or a comma for delimiting the integer and
decimal portions of a number. Here is its syntax:
+</p>
+<p><source>
+<formatNumber value="Expression"
+ [type="Type"] [pattern="Expression"]
+ [currencyCode="Expression"] [currencySymbol="Expression"]
+ [maxIntegerDigits="Expression"] [minIntegerDigits="Expression"]
+ [maxFractionDigits="Expression"] [minFractionDigits="Expression"]
+ [groupingUsed="Expression"]
+ [var="Name"] [locale="Expression"]>
+</source>
+</p>
+<p>
+Only the <code>value</code> attribute is required. It is used to specify the
numeric value that is to be formatted.
+</p>
+<p>
+The value of the <code>type</code> attribute should be either "number", "currency",
or "percentage", and indicates what type of numeric value is being formatted. The
default value for this attribute is "number". The <code>pattern</code> attribute takes
precedence over the <code>type</code> attribute and allows more precise formatting of
numeric values following the pattern conventions of the
<code>java.text.DecimalFormat</code> class.
+</p>
+<p>
+When the <code>type</code> attribute has a value of "currency", the
<code>currencyCode</code> attribute can be used to explicitly specify the currency for
the numerical value being displayed. As with language and country codes, currency
codes are governed by an ISO standard. This code is used to determine the currency
symbol to display as part of the formatted value.
+</p>
+<p>
+Alternatively, you can use the <code>currencySymbol</code> attribute to explicitly
specify the currency symbol. Note that as of JDK 1.4 and the associated introduction
of the <code>java.util.Currency</code> class, the <code>currencyCode</code> attribute
of <code>formatNumber</code> takes precedence over the <code>currencySymbol</code>
attribute. For earlier versions of the JDK, however, the <code>currencySymbol</code>
attribute takes precedence.
+</p>
+<p>
+The <code>maxIntegerDigits</code>, <code>minIntegerDigits</code>,
<code>maxFractionDigits</code>, and <code>minFractionDigits</code> attributes are used
to control the number of significant digits displayed before and after the decimal
point. These attributes require integer values.
+</p>
+<p>
+The <code>groupingUsed</code> attribute takes a <code>Boolean</code> value and
controls whether digits before the decimal point are grouped. For example, in
English-language locales, large numbers have their digits grouped by threes, with each
set of three delimited by a comma. Other locales delimit such groupings with a period
or a space. The default value for this attribute is <code>true</code>.
+</p>
+
+</s2>
+<s2 title="formatDate">
+<p>The <code>formatDate</code> tag provides facilities to format Date values:</p>
+<p>
+<source>
+<formatDate value="Expression" [dateStyle="Style"]
+ [timeStyle="Style"] [pattern="Expression"] [type="Type"] [var="Name"]
+ [locale="Expression"]>
+</source>
+</p>
+<p>
+Only the value attribute is required. Its value should be an instance of the
<code>java.util.Date</code> class, specifying the date and/or time data to be
formatted and displayed.</p>
+
+<p>The optional <code>timeZone</code> attribute indicates the time zone in which
the date and/or time are to be displayed. If not present, then the JVM's default time
zone is used (that is, the time zone setting specified for the local operating
system). </p>
+<p>
+The <code>type</code> attribute indicates which fields of the specified
<code>Date</code> instance are to be displayed, and should be either "time", "date",
or "both". The default value for this attribute is "date", so if no <code>type</code>
attribute is present, the <code>formatDate</code> tag -- true to its name -- will only
display the date information associated with the <code>Date</code> instance, specified
using the tag's value attribute.
+</p>
+<p>
+The <code>dateStyle</code> and <code>timeStyle</code> attributes indicate how the
date and time information should be formatted, respectively. Valid styles are
"default", "short", "medium", "long", and "full". The default value is, naturally,
"default", indicating that a locale-specific style should be used. The semantics for
the other four style values are as defined by the @link{java.text.DateFormat} class.
+</p>
+<p>
+Rather than relying on the built-in styles, you can use the pattern attribute to
specify a custom style. When present, the value of the pattern attribute should be a
pattern string following the conventions of the @link{java.text.SimpleDateFormat}
class. These patterns are based on replacing designated characters within the pattern
with corresponding date and time fields. For example, the pattern MM/dd/yyyy indicates
that two-digit month and date values and a four-digit year value should be displayed,
separated by forward slashes.
+</p>
+<p>
+If the <code>var</code> attribute is specified, then a String value containing the
formatted date is assigned to the named variable. Otherwise, the
<code>formatDate</code> tag will write out the formatting results.
+</p>
+</s2>
<s2 title="macro">
<p>The <code>macro</code> tag allows you define a new custom tag.</p><source>
<macro name="Name" [targetNamespace="Namespace"]>
<parameter name="Name" [optional="Boolean"] [default="Value"]/>*
body
-
</macro>
</source>
<p> For example:</p><source>
1.5 +678 -13
cocoon-2.1/src/java/org/apache/cocoon/generation/JXTemplateGenerator.java
Index: JXTemplateGenerator.java
===================================================================
RCS file:
/home/cvs/cocoon-2.1/src/java/org/apache/cocoon/generation/JXTemplateGenerator.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- JXTemplateGenerator.java 6 Aug 2003 11:31:01 -0000 1.4
+++ JXTemplateGenerator.java 8 Aug 2003 18:49:06 -0000 1.5
@@ -99,6 +99,8 @@
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.LocatorImpl;
+import java.util.*;
+import java.text.*;
/**
* <p>(<em>JX</em> for <a href="http://jakarta.apache.org/commons/jxpath";>Apache
<em>JX</em>Path</a>
@@ -241,6 +243,28 @@
* Either <code>items</code> or both <code>begin</code> and <code>end</code>
* must be present.<p>
*
+ *
+ *
+ * <p>
+ * The <code>formatNumber</code> tag is used to display numeric data, including
currencies and percentages, in a locale-specific manner. The
<code>formatNumber</code>> action determines from the locale, for example, whether to
use a period or a comma for delimiting the integer and decimal portions of a number.
Here is its syntax:
+ * </p>
+ * <p>
+ * <formatNumber value="Expression"
+ * [type="Type"] [pattern="Expression"]
+ * [currencyCode="Expression"] [currencySymbol="Expression"]
+ * [maxIntegerDigits="Expression"] [minIntegerDigits="Expression"]
+ * [maxFractionDigits="Expression"] [minFractionDigits="Expression"]
+ * [groupingUsed="Expression"]
+ * [var="Name"] [locale="Expression"]>
+ * </p>
+ *
+ * <p>The <code>formatDate</code> tag provides facilities to format Date
values:</p>
+ *<p>
+ * <formatDate value="Expression" [dateStyle="Style"]
+ [timeStyle="Style"] [pattern="Expression"] [type="Type"] [var="Name"]
+ [locale="Expression"]>
+ * </p>
+ *
* <p>The <code>macro</code> tag allows you define a new custom tag.</p>
*
* <p><pre>
@@ -389,8 +413,13 @@
if (result == Undefined.instance ||
result == ScriptableObject.NOT_FOUND) {
result = null;
- } else while (result instanceof Wrapper) {
- result = ((Wrapper)result).unwrap();
+
+ } else {
+ if (!(result instanceof NativeJavaClass)) {
+ while (result instanceof Wrapper) {
+ result = ((Wrapper)result).unwrap();
+ }
+ }
}
return result;
} catch (JavaScriptException e) {
@@ -437,8 +466,11 @@
if (result == Undefined.instance ||
result == ScriptableObject.NOT_FOUND) {
result = null;
- } else while (result instanceof Wrapper) {
- result = ((Wrapper)result).unwrap();
+ }
+ if (result instanceof Wrapper) {
+ if (!(result instanceof NativeJavaClass)) {
+ result = ((Wrapper)result).unwrap();
+ }
}
return result;
} finally {
@@ -520,8 +552,12 @@
if (result == Undefined.instance ||
result == ScriptableObject.NOT_FOUND) {
result = null;
- } else while (result instanceof Wrapper) {
- result = ((Wrapper)result).unwrap();
+ } else {
+ if (!(result instanceof NativeJavaClass)) {
+ while (result instanceof Wrapper) {
+ result = ((Wrapper)result).unwrap();
+ }
+ }
}
return result;
} finally {
@@ -559,8 +595,12 @@
if (result == Undefined.instance ||
result == ScriptableObject.NOT_FOUND) {
result = null;
- } else while (result instanceof Wrapper) {
- result = ((Wrapper)result).unwrap();
+ } else {
+ if (!(result instanceof NativeJavaClass)) {
+ while (result instanceof Wrapper) {
+ result = ((Wrapper)result).unwrap();
+ }
+ }
}
return result;
} finally {
@@ -741,6 +781,8 @@
final static String SET = "set";
final static String MACRO = "macro";
final static String PARAMETER = "parameter";
+ final static String FORMAT_NUMBER = "formatNumber";
+ final static String FORMAT_DATE = "formatDate";
/**
@@ -811,12 +853,34 @@
throws SAXException {
Expression res = compileExpr(val, msg, location);
if (res == null) return null;
- if (res.compiledExpression != null) {
+ if (res.compiledExpression == null) {
res.compiledExpression = Integer.valueOf(res.raw);
}
return res;
}
+ // Compile an numeric expression (returns either a Compiled Expression
+ // or an Number literal)
+ private static Expression compileNumber(String val, String msg, Locator
location)
+ throws SAXException {
+ Expression res = compileExpr(val, msg, location);
+ if (res == null) return null;
+ if (res.compiledExpression == null) {
+ res.compiledExpression = Integer.valueOf(res.raw);
+ }
+ return res;
+ }
+
+ private static Expression compileBoolean(String val, String msg, Locator
location)
+ throws SAXException {
+ Expression res = compileExpr(val, msg, location);
+ if (res == null) return null;
+ if (res.compiledExpression == null) {
+ res.compiledExpression = Boolean.valueOf(res.raw);
+ }
+ return res;
+ }
+
private static Expression compile(final String variable, boolean xpath)
throws Exception {
Object compiled;
@@ -828,9 +892,10 @@
return new Expression(variable, compiled);
}
- private Object getValue(Expression expr, JexlContext jexlContext,
+ static private Object getValue(Expression expr, JexlContext jexlContext,
JXPathContext jxpathContext)
throws Exception {
+ if (expr == null) return null;
Object compiled = expr.compiledExpression;
try {
if (compiled instanceof CompiledExpression) {
@@ -851,7 +916,7 @@
}
}
- private int getIntValue(Expression expr, JexlContext jexlContext,
+ static private int getIntValue(Expression expr, JexlContext jexlContext,
JXPathContext jxpathContext)
throws Exception {
Object res = getValue(expr, jexlContext, jxpathContext);
@@ -861,6 +926,42 @@
return 0;
}
+ static private Number getNumberValue(Expression expr, JexlContext jexlContext,
+ JXPathContext jxpathContext)
+ throws Exception {
+ Object res = getValue(expr, jexlContext, jxpathContext);
+ if (res instanceof Number) {
+ return (Number)res;
+ }
+ if (res == null) {
+ return null;
+ }
+ return Double.valueOf(res.toString());
+ }
+
+ static private String getStringValue(Expression expr, JexlContext jexlContext,
+ JXPathContext jxpathContext)
+ throws Exception {
+ Object res = getValue(expr, jexlContext, jxpathContext);
+ if (res != null) {
+ return res.toString();
+ }
+ if (expr != null) {
+ return expr.raw;
+ }
+ return null;
+ }
+
+ static private Boolean getBooleanValue(Expression expr, JexlContext jexlContext,
+ JXPathContext jxpathContext)
+ throws Exception {
+ Object res = getValue(expr, jexlContext, jxpathContext);
+ if (res instanceof Boolean) {
+ return (Boolean)res;
+ }
+ return null;
+ }
+
// Hack: try to prevent JXPath from converting result to a String
private Object getNode(Expression expr, JexlContext jexlContext,
JXPathContext jxpathContext)
@@ -1503,6 +1604,450 @@
final Expression value;
}
+ // formatNumber tag (borrows from Jakarta taglibs JSTL)
+
+ private static final char HYPHEN = '-';
+ private static final char UNDERSCORE = '_';
+
+ private static Locale parseLocale(String locale, String variant) {
+
+ Locale ret = null;
+ String language = locale;
+ String country = null;
+ int index = -1;
+
+ if (((index = locale.indexOf(HYPHEN)) > -1)
+ || ((index = locale.indexOf(UNDERSCORE)) > -1)) {
+ language = locale.substring(0, index);
+ country = locale.substring(index+1);
+ }
+
+ if ((language == null) || (language.length() == 0)) {
+ throw new IllegalArgumentException("No language in locale");
+ }
+
+ if (country == null) {
+ if (variant != null)
+ ret = new Locale(language, "", variant);
+ else
+ ret = new Locale(language, "");
+ } else if (country.length() > 0) {
+ if (variant != null)
+ ret = new Locale(language, country, variant);
+ else
+ ret = new Locale(language, country);
+ } else {
+ throw new IllegalArgumentException("Empty country in locale");
+
+ }
+
+ return ret;
+ }
+
+ private static final String NUMBER = "number";
+ private static final String CURRENCY = "currency";
+ private static final String PERCENT = "percent";
+
+ static class StartFormatNumber extends StartInstruction {
+
+ Expression value;
+ Expression type;
+ Expression pattern;
+ Expression currencyCode;
+ Expression currencySymbol;
+ Expression isGroupingUsed;
+ Expression maxIntegerDigits;
+ Expression minIntegerDigits;
+ Expression maxFractionDigits;
+ Expression minFractionDigits;
+ Expression locale;
+
+ Expression var;
+
+ private static Class currencyClass;
+
+ static {
+ try {
+ currencyClass = Class.forName("java.util.Currency");
+ // container's runtime is J2SE 1.4 or greater
+ } catch (Exception cnfe) {
+ }
+ }
+
+ public StartFormatNumber(StartElement raw,
+ Expression var,
+ Expression value,
+ Expression type,
+ Expression pattern,
+ Expression currencyCode,
+ Expression currencySymbol,
+ Expression isGroupingUsed,
+ Expression maxIntegerDigits,
+ Expression minIntegerDigits,
+ Expression maxFractionDigits,
+ Expression minFractionDigits,
+ Expression locale) {
+ super(raw);
+ this.var = var;
+ this.value = value;
+ this.type = type;
+ this.pattern = pattern;
+ this.currencyCode = currencyCode;
+ this.currencySymbol = currencySymbol;
+ this.isGroupingUsed = isGroupingUsed;
+ this.maxIntegerDigits = maxIntegerDigits;
+ this.minIntegerDigits = minIntegerDigits;
+ this.maxFractionDigits = maxFractionDigits;
+ this.minFractionDigits = minFractionDigits;
+ this.locale = locale;
+ }
+
+ String format(JexlContext jexl, JXPathContext jxp)
+ throws Exception {
+ // Determine formatting locale
+ String var = getStringValue(this.var, jexl, jxp);
+ Number input = getNumberValue(this.value, jexl, jxp);
+ String type = getStringValue(this.type, jexl, jxp);
+ String pattern = getStringValue(this.pattern, jexl, jxp);
+ String currencyCode = getStringValue(this.currencyCode, jexl, jxp);
+ String currencySymbol = getStringValue(this.currencySymbol,
+ jexl, jxp);
+ Boolean isGroupingUsed = getBooleanValue(this.isGroupingUsed,
+ jexl, jxp);
+ Number maxIntegerDigits = getNumberValue(this.maxIntegerDigits,
+ jexl, jxp);
+ Number minIntegerDigits = getNumberValue(this.minIntegerDigits,
+ jexl, jxp);
+ Number maxFractionDigits = getNumberValue(this.maxFractionDigits,
+ jexl, jxp);
+ Number minFractionDigits = getNumberValue(this.minFractionDigits,
+ jexl, jxp);
+ String localeStr = getStringValue(this.locale,
+ jexl, jxp);
+ Locale loc;
+ if (localeStr == null) {
+ loc = Locale.getDefault();
+ } else {
+ loc = parseLocale(localeStr, null);
+ }
+ String formatted;
+ if (loc != null) {
+ // Create formatter
+ NumberFormat formatter = null;
+ if ((pattern != null) && !pattern.equals("")) {
+ // if 'pattern' is specified, 'type' is ignored
+ DecimalFormatSymbols symbols = new DecimalFormatSymbols(loc);
+ formatter = new DecimalFormat(pattern, symbols);
+ } else {
+ formatter = createFormatter(loc,
+ type);
+
+ }
+ if (((pattern != null) && !pattern.equals(""))
+ || 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) {
+ jexl.getVars().put(var, formatted);
+ jxp.getVariables().declareVariable(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) && (currencySymbol == null)) {
+ return;
+ }
+
+ if ((currencyCode != null) && (currencySymbol != null)) {
+ if (currencyClass != null)
+ code = currencyCode;
+ else
+ symbol = currencySymbol;
+ } else if (currencyCode == null) {
+ 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);
+ }
+ }
+ }
+
+ // formatDate tag (borrows from Jakarta taglibs JSTL)
+
+ static class StartFormatDate extends StartInstruction {
+
+ private static final String DATE = "date";
+ private static final String TIME = "time";
+ private static final String DATETIME = "both";
+
+ Expression var;
+ Expression value;
+ Expression type;
+ Expression pattern;
+ Expression timeZone;
+ Expression dateStyle;
+ Expression timeStyle;
+ Expression locale;
+
+ StartFormatDate(StartElement raw,
+ Expression var,
+ Expression value,
+ Expression type,
+ Expression pattern,
+ Expression timeZone,
+ Expression dateStyle,
+ Expression timeStyle,
+ Expression locale) {
+ super(raw);
+ this.var = var;
+ this.value = value;
+ this.type = type;
+ this.pattern = pattern;
+ this.timeZone = timeZone;
+ this.dateStyle = dateStyle;
+ this.timeStyle = timeStyle;
+ this.locale = locale;
+ }
+
+ String format(JexlContext jexl, JXPathContext jxp)
+ throws Exception {
+ String var = getStringValue(this.var, jexl, jxp);
+ Object value = getValue(this.value, jexl, jxp);
+ Object locVal = getValue(this.locale,
+ jexl, jxp);
+ String pattern = getStringValue(this.pattern,
+ jexl, jxp);
+ Object timeZone = getValue(this.timeZone, jexl, jxp);
+
+ String type = getStringValue(this.type, jexl, jxp);
+ String timeStyle = getStringValue(this.timeStyle, jexl, jxp);
+ String dateStyle = getStringValue(this.dateStyle, jexl, jxp);
+
+ String formatted = null;
+
+ // Create formatter
+ Locale locale;
+ if (locVal != null) {
+ if (locVal instanceof Locale) {
+ locale = (Locale)locVal;
+ } else {
+ locale = parseLocale(locVal.toString(), null);
+ }
+ } else {
+ locale = Locale.getDefault();
+ }
+ DateFormat formatter = createFormatter(locale,
+ type,
+ dateStyle,
+ timeStyle);
+ // Apply pattern, if present
+ if (pattern != null) {
+ try {
+ ((SimpleDateFormat) formatter).applyPattern(pattern);
+ } catch (ClassCastException cce) {
+ formatter = new SimpleDateFormat(pattern, locale);
+ }
+ }
+ // Set time zone
+ TimeZone tz = null;
+ if ((timeZone instanceof String)
+ && ((String) timeZone).equals("")) {
+ timeZone = null;
+ }
+ if (timeZone != null) {
+ if (timeZone instanceof String) {
+ tz = TimeZone.getTimeZone((String) timeZone);
+ } else if (timeZone instanceof TimeZone) {
+ tz = (TimeZone) timeZone;
+ } else {
+ throw new IllegalArgumentException("Illegal timeZone value:
\""+timeZone+"\"");
+ }
+ }
+ if (tz != null) {
+ formatter.setTimeZone(tz);
+ }
+ formatted = formatter.format(value);
+ if (var != null) {
+ jexl.getVars().put(var, formatted);
+ jxp.getVariables().declareVariable(var,
+ formatted);
+ return null;
+ }
+ return formatted;
+ }
+
+ private DateFormat createFormatter(Locale loc,
+ String type,
+ String dateStyle,
+ String timeStyle)
+ throws Exception {
+ DateFormat formatter = null;
+ if ((type == null) || DATE.equalsIgnoreCase(type)) {
+ formatter = DateFormat.getDateInstance(getStyle(dateStyle),
+ loc);
+ } else if (TIME.equalsIgnoreCase(type)) {
+ formatter = DateFormat.getTimeInstance(getStyle(timeStyle),
+ loc);
+ } else if (DATETIME.equalsIgnoreCase(type)) {
+ formatter = DateFormat.getDateTimeInstance(getStyle(dateStyle),
+ getStyle(timeStyle),
+ loc);
+ } else {
+ throw new IllegalArgumentException("Invalid type: \""+ type+"\"");
+ }
+ return formatter;
+ }
+
+ private static final String DEFAULT = "default";
+ private static final String SHORT = "short";
+ private static final String MEDIUM = "medium";
+ private static final String LONG = "long";
+ private static final String FULL = "full";
+
+ private int getStyle(String style) {
+ int ret = DateFormat.DEFAULT;
+ if (style != null) {
+ if (DEFAULT.equalsIgnoreCase(style)) {
+ ret = DateFormat.DEFAULT;
+ } else if (SHORT.equalsIgnoreCase(style)) {
+ ret = DateFormat.SHORT;
+ } else if (MEDIUM.equalsIgnoreCase(style)) {
+ ret = DateFormat.MEDIUM;
+ } else if (LONG.equalsIgnoreCase(style)) {
+ ret = DateFormat.LONG;
+ } else if (FULL.equalsIgnoreCase(style)) {
+ ret = DateFormat.FULL;
+ } else {
+ throw new IllegalArgumentException("Invalid style: \"" + style
+"\": should be \"default\" or \"short\" or \"medium\" or \"long\" or \"full\"");
+ }
+ }
+ return ret;
+ }
+ }
+
+
static class Parser implements ContentHandler, LexicalHandler {
StartDocument startEvent;
@@ -1677,6 +2222,94 @@
new StartForEach(startElement, expr,
var, begin, end, step);
newEvent = startForEach;
+ } else if (localName.equals(FORMAT_NUMBER)) {
+ Expression value =
+ compileExpr(attrs.getValue("value"),
+ null, locator);;
+ Expression type =
+ compileExpr(attrs.getValue("type"),
+ null, locator);
+ Expression pattern =
+ compileExpr(attrs.getValue("pattern"),
+ null, locator);
+ Expression currencyCode =
+ compileExpr(attrs.getValue("currencyCode"),
+ null, locator);;
+ Expression currencySymbol =
+ compileExpr(attrs.getValue("currencySymbol"),
+ null, locator);;
+ Expression isGroupingUsed =
+ compileBoolean(attrs.getValue("isGroupingUsed"),
+ null, locator);
+ Expression maxIntegerDigits =
+ compileInt(attrs.getValue("maxIntegerDigits"),
+ null, locator);
+ Expression minIntegerDigits =
+ compileInt(attrs.getValue("minIntegerDigits"),
+ null, locator);
+ Expression maxFractionDigits =
+ compileInt(attrs.getValue("maxFractionDigits"),
+ null, locator);
+ Expression minFractionDigits =
+ compileInt(attrs.getValue("minFractionDigits"),
+ null, locator);
+ Expression var =
+ compileExpr(attrs.getValue("var"),
+ null, locator);
+ Expression locale =
+ compileExpr(attrs.getValue("locale"),
+ null, locator);
+ StartFormatNumber startFormatNumber =
+ new StartFormatNumber(startElement,
+ var,
+ value,
+ type,
+ pattern,
+ currencyCode,
+ currencySymbol,
+ isGroupingUsed,
+ maxIntegerDigits,
+ minIntegerDigits,
+ maxFractionDigits,
+ minFractionDigits,
+ locale);
+ newEvent = startFormatNumber;
+ } else if (localName.equals(FORMAT_DATE)) {
+ Expression var =
+ compileExpr(attrs.getValue("var"),
+ null, locator);
+ Expression value =
+ compileExpr(attrs.getValue("value"),
+ null, locator);;
+ Expression type =
+ compileExpr(attrs.getValue("type"),
+ null, locator);
+ Expression pattern =
+ compileExpr(attrs.getValue("pattern"),
+ null, locator);
+ Expression timeZone =
+ compileExpr(attrs.getValue("timeZone"),
+ null, locator);
+ Expression dateStyle =
+ compileExpr(attrs.getValue("dateStyle"),
+ null, locator);
+ Expression timeStyle =
+ compileExpr(attrs.getValue("timeStyle"),
+ null, locator);
+ Expression locale =
+ compileExpr(attrs.getValue("locale"),
+ null, locator);
+ StartFormatDate startFormatDate =
+ new StartFormatDate(startElement,
+ var,
+ value,
+ type,
+ pattern,
+ timeZone,
+ dateStyle,
+ timeStyle,
+ locale);
+ newEvent = startFormatDate;
} else if (localName.equals(CHOOSE)) {
StartChoose startChoose = new StartChoose(startElement);
newEvent = startChoose;
@@ -2705,8 +3338,8 @@
} catch (Exception e) {
throw new SAXParseException(e.getMessage(),
ev.location,
- e);
- }
+ e);
+ }
if (val == null) {
val = "";
}
@@ -2725,6 +3358,38 @@
startElement.raw,
attrs);
+ } else if (ev instanceof StartFormatNumber) {
+ StartFormatNumber startFormatNumber =
+ (StartFormatNumber)ev;
+ try {
+ String result =
+ startFormatNumber.format(jexlContext,
+ jxpathContext);
+ if (result != null) {
+ char[] chars = result.toCharArray();
+ consumer.characters(chars, 0, chars.length);
+ }
+ } catch (Exception e) {
+ throw new SAXParseException(e.getMessage(),
+ ev.location,
+ e);
+ }
+ } else if (ev instanceof StartFormatDate) {
+ StartFormatDate startFormatDate =
+ (StartFormatDate)ev;
+ try {
+ String result =
+ startFormatDate.format(jexlContext,
+ jxpathContext);
+ if (result != null) {
+ char[] chars = result.toCharArray();
+ consumer.characters(chars, 0, chars.length);
+ }
+ } catch (Exception e) {
+ throw new SAXParseException(e.getMessage(),
+ ev.location,
+ e);
+ }
} else if (ev instanceof StartPrefixMapping) {
StartPrefixMapping startPrefixMapping =
(StartPrefixMapping)ev;
