xmlns:lxslt="http://xml.apache.org/xslt"

The lxslt namespace provides support for the lxslt:component element and lxslt:script subelement.

You may also use the LotusXSL alias for this namespace: "http://xsl.lotus.com/".

xmlns:prefix=URI

The prefix identifies the namespace, and URI is one of the following:

• An arbitrary (but unique) string that matches the prefix attribute of an lxslt:component element in the stylesheet.
  Example: xmlns:ext1="xyz"
  
  
• [class:]FQCN
  where FQCN is a Java fully qualified class name. If the extension only involves static class method calls (no instance constructors or instance method calls) precede the class name with class:.
  Example: xmlns:ext2="java.util.Hashtable"
  
  
• The file name or URL for another document that contains the lxslt:component element.
  Example: xmlns:ext3="my-component.txt"

Xalan-Java identifies the URI by working through the list above. In other words, if the URI does not match an lxslt:component element prefix in the stylesheet, Xalan-Java attempts to map the URI to a fully qualified class name on the class path, and so on.

If the stylesheet contains an lxslt:component element with a prefix attribute set to the extension prefix, the only function of the URI is to provide a unique namespace. If the stylesheet does not contain an lxslt:component, the URI must identify a Java class or a document containing the lxslt:component.

In the stylesheet element:

extension-element-prefixes="prefix-1 prefix-2 ..."

In a literal result element or extension element include the xsl prefix:

xsl:extension-element-prefixes="prefix1 prefix2 ..."

Keep in mind that where you declare namespaces and designate extension prefixes determines the scope of those namespaces.To make your extensions available throughout the stylesheet, include these settings and attribute in the stylesheet element.

By default, namespace declarations are included in the transformation output. To exclude namespaces from the output, use

exclude-result-prefixes="prefix-1 prefix-2 ..."

in the stylesheet element or

xsl:exclude-result-prefixes="prefix-1 prefix-2 ..."

in a literal result element or extension element.

In the scope of the xslt namespace declaration:

<lxslt:component prefix="prefix"
    functions="func-1 func-2 ...func-n"
    elements="elem-1 elem-2 ...elem-n">
  <!--See lxslt:script below-->
</lxslt:component>

where func-1 func-2 ... func-n and elem-1 elem-2 ... elem-n designate the functions and elements the extension provides and the stylesheet uses. You can use the function-available and element-available functions to determine at run time whether a function or element designated in the lxslt:component is actually available.

If your extension namespace is a fully qualified class name, you do not need to include the lxslt:component. If you do not include it, you cannot use the function-available and element-available functions to determine whether a given element or function is actually available at runtime.

In each lxslt:component, you must include an lxslt:script element. If the extension is implemented in Java:

<lxslt:script lang="javaclass" src="[class:]FQCN"/>

where FQCN is the fully qualified class name. If the extension only involves static class method calls (no instance constructors or instance method calls) precede the class name with class:.
Example: <lxslt:script lang="javaclass"
          src="java.util.Hashtable"/>

If the extension is implemented in JavaScript:

<lxslt:script lang="javascript" >
  <!--The implementation script-->
</lxslt:script>

For other scripting languages supported by BSF, use the same approach as for JavaScript. Xalan-Java plans to add support for using the src attribute to identify another document that contains the implementation script; this feature is not yet supported.

For each extension element in a namespace, the implementation must be a Java method with the following signature, or the scripting language equivalent:

Type element(org.apache.xalan.xslt.XSLProcessorContext,
             org.w3c.dom.Element extensionElement)

where Type designates the return type and element is the local part of the extension element name (the element name without the namespace prefix).

If the extension element is implemented in a loosely typed scripting language, such as JavaScript, the arguments and return value are untyped.

Caution: The value returned by an extension element is placed in the transformation result. If you are not interested in a return value, use a public void Java method or return null from a scripting language function.

Java example: public void myElement
         (org.apache.xalan.xslt.XSLProcessorContext,
          org.w3c.dom.Element extensionElement)

JavaScript example: function myElement(xslProcContext, element)

The Redirect extension (org.apache.xalan.xslt.extensions.Redirect) is shipped with Xalan-Java (more extensions are on the way!).

A standard XSL transformation involves three parameters: the XML source tree, an XSL stylesheet, and the transformation result tree. Whether the result tree is output to a file, a character stream, a byte stream, a DOM, or a SAX document handler, the initial transformation sends the entire result to a single target, represented by the XSLTResultTarget class.

The Redirect extension supplies three extension elements that you can use to redirect portions of your transformation output to multiple files: <open>, <write>, and <close>. If you use the <write> element alone, the extension opens a file, writes to it, and closes the file immediately. If you want explicit control over the opening and closing of files, use <write> in conjunction with the <open> and <close> elements.

Each of these elements includes a file attribute and/or a select attribute to designate the output file. The file attribute takes a string, so you can use it to directly specify the output file name; The select attribute takes an XPath expression, so you can use it to dynamically generate the output file name. If you include both attributes, the Redirect extension first evaluates the select attribute, and falls back to the file attribute if the select attribute expression does not return a valid file name.

Suppose you are outputting the bulk of your result tree to one file, but you want to output the transformation of all <foo> elements and their children to another file. The following example illustrates the basic structure of the XML source:

	<?xml version="1.0"?> <doc> <foo file="foo.out"> Testing Redirect extension: <bar>A foo subelement text node</bar> </foo> <main> Everything else </main> </doc>

This stylesheet redirects part of the output to a secondary file:

	<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:lxslt="http://xml.apache.org/xslt" xmlns:redirect="org.apache.xalan.xslt.extensions.Redirect" extension-element-prefixes="redirect"> <xsl:template match="/"> <standard-out> Standard output: <xsl:apply-templates/> </standard-out> </xsl:template> <xsl:template match="main"> <main> <xsl:apply-templates/> </main> </xsl:template> <xsl:template match="/doc/foo"> <redirect:write select="@file"> <foo-out> <xsl:apply-templates/> </foo-out> </redirect:write> </xsl:template> <xsl:template match="bar"> <foobar-out> <xsl:apply-templates/> </foobar-out> </xsl:template> </xsl:stylesheet>

The standard output is:

	<?xml version="1.0" encoding="UTF-8"?> <standard-out> Standard output: <main> Everything else. </main> <standard-out>

The output redirected to foo.out is:

	<?xml version="1.0" encoding="UTF-8"?> <foo-out> Testing Redirect extension: <foobar-out>foo subelement text node</foobar-out> </foo-out>

For more information on using the Redirect extension to send output to multiple files, see Redirect class.

The XSLT data types map to Java data types as follows:

For the XSLT boolean and number types, Xalan-Java first looks for a method with the corresponding Java primitive type. If it does not find such a method, it looks for a method with the object type. In the case of the foo:bar(10) static method call, for example, Xalan-Java first looks for bar(double). If it does not find such a method, it looks for for bar(java.lang.Double).

When an extension function is invoked, the arguments are converted as indicated above, and sent to the extension. No conversion takes place for arguments of non-XSLT types.

Use the following syntax to instantiate Java objects and to call methods:

prefix:FQCN.new (args)

where prefix is the extension namespace prefix and FQCN is the fully qualified class name of which a new instance is to be created with the args constructor arguments (if any).
Example: variable myHash
       select"my-ext:java.util.Hashtable.new()"

prefix:FQCN.methodName (args)

where FQCN is the fully qualified class name whose static method methodName is to be invoked using the args arguments.
Example: variable new-pop
        select="my-ext:java.lang.Integer.valueOf(string(@population))"

prefix:methodName (object, args)

where methodName is the name of the method to invoke on object with the args arguments.
Example: variable old-pop
       select="my-ext:put($myHash, string(@region), $new-pop)"

Please keep in mind that all LocationPath expressions return a node-set, even if the expression only returns a single attribute or a text node (node-sets with one member). You can use the XSLT string() function (as in the syntax examples above) to convert a node-set value to string, and the number() function to convert a node-set value to number (a double).

If you want to pass a node-set to an extension function, set up a Java method to accept an org.w3c.dom.NodeList (or an org.apache.xalan.xpath.MutableNodeList, which extends NodeList, if you want to modify the nodes).

Suppose, for example, you have a myExtensions.ProcessNodes class with the following doSomething method:

public static boolean doSomething(org.w3c.dom.NodeList nList)

Assuming you set up this extension in the node-ext namespace, any of the following extension calls from a stylesheet are syntactically possible:

<!--Process the current node-->
<xsl:variable name="success" select="node-ext:MyExtensions.ProcessNodes.doSomething(.)"/>

<!--Process all nodes in current context-->
<xsl:variable name="success" select="node-ext:MyExtensions.ProcessNodes.doSomething(*)"/>

<!-- Process all nodes -->
<xsl:variable name="success" select="node-ext:MyExtensions.ProcessNodes.doSomething(/*)"/>

<!--Process the foo/baz nodes in current context -->
<xsl:variable name="success" select="node-ext:MyExtensions.ProcessNodes.doSomething(foo/baz)"/>

<!--Process the/foo/baz and /bar/saz nodes -->
<xsl:variable name="success" select="node-ext:MyExtensions.ProcessNodes.doSomething(/foo/baz | /bar/saz)"/>

The NodeList is in fact a list of references into the XML document, so keep in mind that getNextSibling(), for example, gets you the next sibling in the document, which may not be the next Node in the NodeList.

For each extension function in a namespace, the implementation must include a Java method with the following signature, or the scripting language equivalent:

public object function(args)

where object is the return type, function is the local part of the extension function name (the function name without the namespace prefix), and args correspond to the arguments in the function call.

xmlns:lxslt="http://xml.apache.org/xslt/java"

You may also use the LotusXSL alias for this namespace: "http://xsl.lotus.com/java".

Use "java" as the prefix with the syntax described in Extension function Java calls.

That is all. You do not need to set an extension-element-prefixes attribute, and you do not include an lxslt:component element. Given the absence of the lxslt:component element, you cannot use the function-available method to determine at runtime whether a Java method call is actually available.

Using the java namespace clearly involves less setup than using your own namespace, as long as these restrictions are not a problem. Remember that you always have the option of setting up your own namespace and extra overhead is really minimal.

This example uses extension functions to call the SimpleDateFormat class and the IntDate class. IntDate uses String arguments to set up a Date object:

	import java.util.Date; import java.util.Calendar; public class IntDate { public static Date getDate(String year, String month, String day) { // Date(int, int, int) has been deprecated, so use Calendar to // set the year, month, and day. Calendar c = Calendar.getInstance(); // Convert each argument to int. c.set(Integer.parseInt(year),Integer.parseInt(month),Integer.parseInt(day)); return c.getTime(); } }

The template transforms date elements with four attributes. For example, it transforms <date format="EEEE, MMM dd, yyyy" year="2000" month="4" day="27"/> into <p>Date: Thursday, April 27, 2000.</p>.

As you review this stylesheet, please keep the following in mind:

• The exclude-result-prefixes stylesheet attribute prevents the java namespace declaration from appearing in the output.
• The XSLT type returned by any LocationPath expression is node-set, so the XSLT string function is used to convert the format, year, month, and day attribute values from node-sets to strings.
• The format attribute provides a String argument for constructing a java.text.SimpleDateFormat object.
• The IntDate class uses String values provided by the year, month, and day attributes, to set the date. XSLT can pass number values, but these are converted into doubles.
• The formatter variable holds a SimpleDateFormat object, and the date variable holds a Date object. XSLT does not understand either of these types, but they are used to call the SimpleDateFormat format method. In that call, $formatter is the object, and $date is the argument. The syntax for calling Java constructors and methods is described above in Extension function Java calls.

	<?xml version="1.0"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:java="http://xml.apache.org/xslt/java" exclude-result-prefixes="java"> <!--Other templates for transforming the rest of the XML source documents--> <xsl:template match="date"> <xsl:variable name="year" select="string(./@year)"/> <xsl:variable name="month" select="string(./@month)"/> <xsl:variable name="day" select="string(./@day)"/> <xsl:variable name="format" select="string(./@format)"/> <xsl:variable name="formatter" select="java:java.text.SimpleDateFormat.new($format)"/> <xsl:variable name="date" select="java:IntDate.getDate($year, $month, $day)"/> <p>Date: <xsl:value-of select="java:format($formatter, $date)"/></p> </xsl:template> </xsl:stylesheet>

MyCounter.java

	Import java.util.*; public class MyCounter { Hashtable counters = new Hashtable (); public MyCounter () {} public void init(org.apache.xalan.xslt.XSLProcessorContext context, org.apache.xalan.xslt.ElemExtensionCall extElem) { String name = extElem.getAttribute("name"); String value = extElem.getAttribute("value"); int val; try { val = Integer.parseInt (value); } catch (NumberFormatException e) { e.printStackTrace (); val = 0; } counters.put (name, new Integer (val)); } public int read(String name) { Integer cval = (Integer) counters.get (name); return (cval == null) ? 0 : cval.intValue (); } public void incr(org.apache.xalan.xslt.XSLProcessorContext context, org.apache.xalan.xslt.ElemExtensionCall extElem) { String name = extElem.getAttribute("name"); Integer cval = (Integer) counters.get(name); int nval = (cval == null) ? 0 : (cval.intValue () + 1); counters.put (name, new Integer (nval)); } }

An XML source document:

	<?xml version="1.0"?> <doc> <name first="David" last="Marston"/> <name first="David" last="Bertoni"/> <name first="Donald" last="Leslie"/> <name first="Emily" last="Farmer"/> <name first="Jack" last="Donohue"/> <name first="Myriam" last="Midy"/> <name first="Paul" last="Dick"/> <name first="Robert" last="Weir"/> <name first="Scott" last="Boag"/> <name first="Shane" last="Curcuru"/> </doc>

The stylesheet:

	<?xml version="1.0"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:lxslt="http://xml.apache.org/xslt" xmlns:counter="MyCounter" extension-element-prefixes="counter" version="1.0"> <lxslt:component prefix="counter" elements="init incr" functions="read"> <lxslt:script lang="javaclass" src="MyCounter"/> </lxslt:component> <xsl:template match="/"> <HTML> <H1>Names in alphabetical order</H1> <counter:init name="index" value="1"/> <xsl:for-each select="doc/name"> <xsl:sort select="@last"/> <xsl:sort select="@first"/> <p> <xsl:text>[</xsl:text> <xsl:value-of select="counter:read('index')"/> <xsl:text>]. </xsl:text> <xsl:value-of select="@last"/> <xsl:text>, </xsl:text> <xsl:value-of select="@first"/> </p> <counter:incr name="index"/> </xsl:for-each> </HTML> </xsl:template> </xsl:stylesheet>

Transformation output:

	<HTML> <H1>Names in alphabetical order</H1> <p>[1]. Bertoni, David</p> <p>[2]. Boag, Scott</p> <p>[3]. Curcuru, Shane</p> <p>[4]. Dick, Paul</p> <p>[5]. Donohue, Jack</p> <p>[6]. Farmer, Emily</p> <p>[7]. Leslie, Donald</p> <p>[8]. Marston, David</p> <p>[9]. Midy, Myriam</p> <p>[10]. Weir, Robert</p> </HTML>

	<?xml version="1.0"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:lxslt="http://xml.apache.org/xslt" xmlns:counter="MyCounter" extension-element-prefixes="counter" version="1.0"> <lxslt:component prefix="counter" elements="init incr" functions="read"> <lxslt:script lang="javascript"> var counters = new Array(); function init (xslproc, elem) { name = elem.getAttribute ("name"); value = parseInt(elem.getAttribute ("value")); counters[name] = value; return null; } function read (name) { // Return a string. return "" + (counters[name]); } function incr (xslproc, elem) { name = elem.getAttribute ("name"); counters[name]++; return null; } </lxslt:script> </lxslt:component> <xsl:template match="/"> <HTML> <H1>Names in alphatebical order</H1> <counter:init name="index" value="1"/> <xsl:for-each select="doc/name"> <xsl:sort select="@last"/> <xsl:sort select="@first"/> <p> <xsl:text>[</xsl:text> <xsl:value-of select="counter:read('index')"/> <xsl:text>]. </xsl:text> <xsl:value-of select="@last"/> <xsl:text>, </xsl:text> <xsl:value-of select="@first"/> </p> <counter:incr name="index"/> </xsl:for-each> </HTML> </xsl:template> </xsl:stylesheet>

This stylesheet produces the same output as the preceding example with the Java extension.