XSLT is not an object oriented language. Static methods fit much more neatly into its structures than do objects and instance methods. If I’m writing a method just for XSLT, I’ll normally make it static if at all possible. However, Saxon can use instance methods as extension functions too. As before, the fully package qualified class name must be bound to a namespace prefix. The constructor for the class can be called using the special local function name new(). For example, this template retrieves the current time using the Java Date class:

<xsl:template name="currentTime" 
              xmlns:date="java:java.util.Date">
  <xsl:value-of select="date:new()"/>
</xsl:template>

date:new() in XSLT is basically the same thing as new Date() in Java. When the Date constructor is invoked with no arguments, Java initializes the resulting Date object to the current time. You can also pass arguments to constructors, just like you can to static methods.

The object the new() function returns is normally assigned to a variable. You can pass this variable to other extension functions as an argument. To invoke instance methods on that object, pass the variable that points to the object whose instance method you’re invoking as the first argument to the instance method. Then the normal first argument gets pushed over to become the second argument, the second argument becomes the third, and so on. For example, this template uses the GregorianCalendar class to get today’s date. First it uses the static getInstance() method to return a GregorianCalendar object initialized to the current time. Then it passes the appropriate integer constants to the get() instance method to retrieve the month, day, and year. It produces the current date in the form 2002-3-26.

<xsl:template name="today" 
              xmlns:cal="java:java.util.GregorianCalendar">
  <xsl:variable name="rightNow" select="cal:getInstance()" />
  <!-- The Calendar class uses zero-based months; 
       i.e. January is month 0, February is month 1, and 
       so on. We have to add one to get the customary month 
       number. -->
  <xsl:variable name="month" select="cal:get($rightNow, 2) + 1" />
  <xsl:variable name="day" select="cal:get($rightNow, 5)" />
  <xsl:variable name="year" select="cal:get($rightNow, 1)" />
  <xsl:value-of 
   select="$year" />-<xsl:value-of 
   select="$month" />-<xsl:value-of 
   select="$day" />
</xsl:template>

Calendar rightNow = Calendar.getInstance();
// Months are zero-based; i.e. January is month 0, February is
// month 1, and so on. We have to add one to get the customary
// month number.
String month = rightNow.get(Calendar.MONTH) + 1;
String date  = rightNow.get(Calendar.DATE);
String year  = rightNow.get(Calendar.YEAR);
String result = year + "-" + month + "-" + date;

Xalan can use instance methods as extension functions too. The new() function invokes the constructor for the class and can take whatever arguments the constructor requires. For example, this template retrieves the current time using the Java Date class:

<xsl:template name="currentTime" 
              xmlns:java="http://xml.apache.org/xslt/java">
  <xsl:value-of select="java:java.util.Date.new()"/>
</xsl:template>

If the prefix is bound to a specific class, you can omit the class name. For example,

<xsl:template name="currentTime" 
              xmlns:date="xalan://java.util.Date">
  <xsl:value-of select="date:new()"/>
</xsl:template>

The object the new() function returns can be assigned to an XSLT variable that can then be passed as an argument to other extension functions or used to invoke instance methods on the object. As in Saxon, to invoke an instance method pass the object whose method you’re invoking as the first argument to the method. For example, here’s the Xalan version of the GregorianCalendar template that produces the current date in the form 2002-3-26.

<xsl:template name="today" 
              xmlns:cal="xalan://java.util.GregorianCalendar">
  <xsl:variable name="rightNow" select="cal:getInstance()" />
  <!-- The GregorianCalendar class counts months from zero
       so we have to add one to get the customary number -->
  <xsl:variable name="month" select="cal:get($rightNow, 2) + 1" />
  <xsl:variable name="day" select="cal:get($rightNow, 5) " />
  <xsl:variable name="year" select="cal:get($rightNow, 1)" />
  <xsl:value-of 
   select="$year" />-<xsl:value-of 
   select="$month" />-<xsl:value-of 
   select="$day" />
</xsl:template>

Like Saxon, Xalan also doesn’t let you access fields in a class, so once again it’s necessary to use the actual values instead of the named constants for the arguments to the get() method.

Exceptions thrown by extension functions have the same results in Xalan as in Saxon; that is, the the XSLT processing halts, possibly in the middle of transforming a document. Once again, it’s probably a good idea to design your extension functions so that they handle all probable exceptions internally and always return a sensible result.

Xalan converts method arguments and return types between Java and XSLT types in a mostly intuitive way. Table 17.1 lists the conversions from XSLT’s five types to Java types in order of preference:

Moving in the other direction from Java to XSLT, the conversions are fairly obvious. Table 17.2 summarizes them. Besides the ones listed here, other object types will normally be converted to a string using their toString() method if they’re actually dereferenced somewhere in the stylesheet. However, their original type will be maintained when they’re passed back to another extension function.

There is one thing Xalan extension functions can do that Saxon extension functions can’t. A Xalan extension function can receive the current XSLT context as an argument. This provides information about the context node, the context node position, the context node list, and variable bindings. Admittedly, needing to know this information inside an extension function is rare. Most operations that consider the current context are more easily implemented in XSLT than Java. Nonetheless, if you need to know this for some reason, you can declare that the initial argument to your function has type org.apache.xalan.extensions.ExpressionContext; for example,

You do not need to pass an argument of this type explicitly. Xalan will create an ExpressionContext object for you and pass it to the method automatically. Furthermore, Xalan will always pick a method that takes an ExpressionContext over one that does not.

This Xalan-J ExpressionContext interface, shown in Example 17.20, provides methods to get the context and the context node list, convert the context node into either its string or number value (as defined by the XPath string() and number() functions), and to get the XPath object bound to a known variable or parameter.

package org.apache.xalan.extensions;

public interface ExpressionContext {

  public Node         getContextNode();
  public NodeIterator getContextNodes();
  public double       toNumber(Node n);
  public String       toString(Node n);
  public XObject      getVariableOrParam(
   org.apache.xml.utils.QName qualifiedName)
   throws javax.xml.transform.TransformerException;

}