<target name="testParameterTypes" depends="setUp" description="parameters of various data types and XPath expressions">

    <property name="antProperty1" value="ANT_PROPERTY_1"/>

    <property name="antProperty2" value="ANT_PROPERTY_2"/>

    <property name="antProperty3" value="3"/>

    <property name="antProperty4" value="substring-before"/>

    <xslt in="${legacy.dir}/data.xml"

          out="${output}/out.xml">

      <param name="p1" expression="123" type="INT"/>

      <param name="p2" expression="64 * 64 div 128 + 10" type="XPATH_NUMBER"/>

      <param name="p3" expression="${antProperty4}($antProperty2, '_')" type="XPATH_STRING"/>

      <style>

        <string><![CDATA[<xsl:stylesheet

  version="1.0"

  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

  xmlns:fo="http://www.w3.org/1999/XSL/Format">

<!-- get the xsl-parameter -->

<xsl:param name="p1"/>

<xsl:param name="p2"/>

<xsl:param name="p3"/>

<!-- use the xsl-parameter -->

<xsl:template match="/">

p1_result='<xsl:value-of select="$p1 + 321"/>'

p2_result='<xsl:value-of select="$p2"/>'

p3_result='<xsl:value-of select="$p3"/>'

</xsl:template>

</xsl:stylesheet>

]]></string>

      </style>

    </xslt>

    <au:assertResourceContains resource="${output}/out.xml" value="p1_result='444'"/>

    <au:assertResourceContains resource="${output}/out.xml" value="p2_result='42'"/>

    <au:assertResourceContains resource="${output}/out.xml" value="p3_result='ANT'"/>

  </target>

/*

 *  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.tools.ant.taskdefs;

/**

 * Extends Proxy interface for XSLT processors: adds support for XSLT parameters

 * of various types (not only String)

 *

 *

 * @see XSLTProcess

 * @author Frantisek Kucera (xkucf03)

 * @since Ant 1.9.3

 */

public interface XSLTLiaison4 extends XSLTLiaison3 {

    /**

     * Add a parameter to be set during the XSL transformation.

     *

     * @param name the parameter name.

     * @param value the parameter value as String, Boolean, int, etc.

     * @throws Exception thrown if any problems happens.

     * @since Ant 1.9.3

     * @see Transformer#setParameter(java.lang.String, java.lang.Object)

     */

    void addParam(String name, Object value) throws Exception;

}

     * @see XSLTLiaison4#addParam(java.lang.String, java.lang.Object) 

import java.util.ArrayList;

import java.util.Collections;

import java.util.EnumMap;

import java.util.List;

import java.util.Map;

import javax.xml.namespace.QName;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathExpression;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import javax.xml.xpath.XPathVariableResolver;

    /**

     * For evaluating template params

     *

     * @since Ant 1.9.3

     */

    private XPathFactory xpathFactory;

    /**

     * For evaluating template params

     *

     * @since Ant 1.9.3

     */

    private XPath xpath;

    @Override

        /**

         * Type of the expression.

         * @see ParamType

         */

        private String type;

         * @see ParamType

         * @since Ant 1.9.3

         */

        public void setType(String type) {

            this.type = type;

        }

        /**

         * @see #getType()

         * @see ParamType

         * @since Ant 1.9.3

         */

        public String getType() {

            return type;

        }

        /**

    /**

     * Enum for types of the parameter expression.

     *

     * <p>The expression can be:</p>

     * <ul>

     * <li>primitive type that will be parsed from the string value e.g.

     * {@linkplain Integer#parseInt(java.lang.String)}</li>

     * <li>XPath expression that will be evaluated (outside of the transformed

     * document - on empty one) and casted to given type. Inside XPath

     * expressions the Ant variables (properties) can be used (as XPath

     * variables - e.g. $variable123). n.b. placeholders in form of

     * ${variable123} will be substituted with their values before evaluating the

     * XPath expression (so it can be used for dynamic XPath function names and

     * other hacks).</li>

     * </ul>

     * <p>The parameter will be then passed to the XSLT template.</p>

     *

     * <p>Default type (if omited) is primitive String. So if the expression is e.g

     * "true" with no type, in XSLT it will be only a text string, not true

     * boolean.</p>

     * 

     * @see Param#setType(java.lang.String)

     * @see Param#setExpression(java.lang.String)

     * @since Ant 1.9.3

     */

    public enum ParamType {

        STRING,

        BOOLEAN,

        INT,

        LONG,

        DOUBLE,

        XPATH_STRING,

        XPATH_BOOLEAN,

        XPATH_NUMBER,

        XPATH_NODE,

        XPATH_NODESET;

        public static final Map<ParamType, QName> XPATH_TYPES;

        static {

            Map<ParamType, QName> m = new EnumMap<ParamType, QName>(ParamType.class);

            m.put(XPATH_STRING, XPathConstants.STRING);

            m.put(XPATH_BOOLEAN, XPathConstants.BOOLEAN);

            m.put(XPATH_NUMBER, XPathConstants.NUMBER);

            m.put(XPATH_NODE, XPathConstants.NODE);

            m.put(XPATH_NODESET, XPathConstants.NODESET);

            XPATH_TYPES = Collections.unmodifiableMap(m);

        }

    }

    @Override

        xpathFactory = XPathFactory.newInstance();

        xpath = xpathFactory.newXPath();

        xpath.setXPathVariableResolver(new XPathVariableResolver() {

            public Object resolveVariable(QName variableName) {

                return getProject().getProperty(variableName.toString());

            }

        });

    /**

     * Evaluates parameter expression according to its type.

     *

     * @param param parameter from Ant build file

     * @return value to be passed to XSLT as parameter

     * @throws IllegalArgumentException if param type is unsupported

     * @throws NumberFormatException if expression of numeric type is not

     * desired numeric type

     * @throws XPathExpressionException if XPath expression can not be compiled

     * @since Ant 1.9.3

     */

    private Object evaluateParam(Param param) throws XPathExpressionException {

        String typeName = param.getType();

        String expression = param.getExpression();

        ParamType type;

        if (typeName == null || typeName.isEmpty()) {

            type = ParamType.STRING; // String is default

        } else {

            try {

                type = ParamType.valueOf(typeName);

            } catch (IllegalArgumentException e) {

                throw new IllegalArgumentException("Invalid XSLT parameter type: " + typeName, e);

            }

        }

        switch (type) {

            case STRING:

                return expression;

            case BOOLEAN:

                return Boolean.parseBoolean(expression);

            case DOUBLE:

                return Double.parseDouble(expression);

            case INT:

                return Integer.parseInt(expression);

            case LONG:

                return Long.parseLong(expression);

            default: // XPath expression

                QName xpathType = ParamType.XPATH_TYPES.get(type);

                if (xpathType == null) {

                    throw new IllegalArgumentException("Invalid XSLT parameter type: " + typeName);

                } else {

                    XPathExpression xpe = xpath.compile(expression);

                    // null = evaluate XPath on empty XML document

                    return xpe.evaluate((Object) null, xpathType);

                }

        }

    }

    /**

     * Add a parameter.

     * @param name the name of the parameter

     * @param value the value of the parameter

     * @since Ant 1.9.3

     */

    public void addParam(String name, Object value) {

        params.put(name, value);

    }

    <td valign="top">type</td>

    <td valign="top">

        Data type of the parameter. Possible values are:

        <ul>

            <li><code>STRING</code></li>

            <li><code>BOOLEAN</code></li>

            <li><code>INT</code></li>

            <li><code>LONG</code></li>

            <li><code>DOUBLE</code></li>

            <li><code>XPATH_STRING</code></li>

            <li><code>XPATH_BOOLEAN</code></li>

            <li><code>XPATH_NUMBER</code></li>

            <li><code>XPATH_NODE</code></li>

            <li><code>XPATH_NODESET</code></li>

        </ul>

        <em>since Ant 1.9.3</em>

    </td>

    <td align="center" valign="top">No; default is <code>STRING</code></td>

  </tr>

  <tr>

  <p>      

      The <code>XPATH_*</code> types says that the <code>expression</code> is not just a primitive-type value but an XPath expression.

      This expression will be evaluated on an empty XML document and the result will be passed to the XSLT transformer as a parameter of given type.

      In these expressions the declared Ant properties can be used as XPath variables e.g. <code>$someProperty</code>.

      So you can compute something using standard XPath functions and operators.

  </p>

  <p>

      If you write <code>${someProperty}</code> instead of <code>$someProperty</code>,

      the value will be simply substituted by Ant before evaluating the XPath expression

      (this substitution works also for primitive types).

  </p>

  <p>Simple String parameter:</p>

  <p>Various data types and XPath expressions:</p>

  <pre>&lt;property name="antProperty1" value="ANT_PROPERTY_1"/&gt;

<property name="antProperty2" value="ANT_PROPERTY_2"/>

<property name="antProperty3" value="3"/>

<property name="antProperty4" value="substring-before"/>

<!--

  ${this} is substituted by Ant itself

  and $this is evaluated by XPath as a variable

-->

<xslt in="in.xml" out="out.xml" style="template.xsl">

  <!-- Simple String parameter: -->

  <param name="p0" expression="some nice string" type="STRING"/>

  <!-- A value substituted by Ant -->

  <param name="p1" expression="some string with ${antProperty1} constructed by Ant" type="STRING"/>

  <!-- XPath resulting in: and this is done in XPath: ANT_PROPERTY_2 -->

  <param name="p2" expression="concat('and this is done in XPath: ', $antProperty2)" type="XPATH_STRING"/>

  <!-- Some XPath math, result: 42 -->

  <param name="p3" expression="64 * 64 div 128 + 10" type="XPATH_NUMBER"/>

  <!-- Some numeric parameter: -->

  <param name="p4" expression="123.45" type="DOUBLE"/>

  <!-- XPath expression, result: true boolean -->

  <param name="p5" expression="$antProperty1 = 'ANT_PROPERTY_1'" type="XPATH_BOOLEAN"/>

  <!-- First one is an XPath variable, second one is a text substituted by Ant, result: true boolean -->

  <param name="p6" expression="$antProperty2 = '${antProperty2}'" type="XPATH_BOOLEAN"/>

  <!-- Some XPath math with a variable, result: 64 -->

  <param name="p7" expression="$antProperty3 * 4 * 5 + 4" type="XPATH_NUMBER"/>

  <!-- 

    XPath expression with substituted function name and a variable:

    substring-before($antProperty2, '_')

    result: ANT

  -->

  <param name="p8" expression="${antProperty4}($antProperty2, '_')" type="XPATH_STRING"/>

  <!-- Without type attribute: -->

  <param name="p9" expression="default type is String"/>

&lt;/xslt&gt;</pre>