2.2.1. XML Tree Data Structure

Figure 2-2. Tree structure for discussionForumHome.xml

A tree data structure is fundamentally recursive because it consists of leaf nodes and smaller trees. Each of these smaller trees, in turn, also consist of leaf nodes and still smaller trees. Algorithms that deal with tree structures can almost always be expressed recursively, and XSLT is no exception. The processing model adopted by XSLT is explicitly designed to take advantage of the recursive nature of every well-formed XML document. This means that most stylesheets can be broken down into highly modular, easily understandable pieces, each of which processes a subset of the overall tree (i.e., a subtree).

2.2.2. Recursive Processing with Templates

As the XSLT transformation process continues, the current node and current node list are constantly changing. This is a good thing, since you do not want to constantly search for patterns beginning from the document root element. You are not limited to traversing down the tree, however; you can iterate over portions of the XML data many times or navigate back up through the document tree structure. This gives XSLT a huge advantage over CSS because CSS is limited to displaying the XML in the order in which it appears in the document.

Comparing <xsl:template> to <xsl:apply-templates>   One way to understand the difference between <xsl:template> and <xsl:apply-templates> is to think about the difference between a Java method and the code that invokes the method. For example, a method in Java is declared as follows:   public void printMessageBoard(MessageBoard board) { // print information about the message board }   In XSLT, the template plays a similar role:   <xsl:template match="messageBoard"> <!-- print information about the message board </xsl:template>   In order to invoke the Java method, use the following Java code:   someObject.printMessageBoard(currentBoard);   And in XSLT, use:   <xsl:apply-templates select="..."/>   to instantiate the template using the current <messageBoard> node.   While this is a good comparison to help illustrate the difference between <xsl:template> and <xsl:apply-templates>, it is important to remember that the XSLT model is not really a method call. Instead, <xsl:apply-templates> instructs the processor to scan through the XML document again, looking for nodes that match a pattern. If matching nodes are found, the best matching template is instantiated.   In the next chapter, we will see that XSLT also has <xsl:call-template>, which works similarly to a Java method call.

Let's suppose that your source document contains the following XML:

<school>
  <name>SIUC</name>
  <city>Carbondale</city>
  <state>Illinois</state>
</school>

The following template could be used to match the <school> element and output its contents:

<xsl:template match="school">
  <b><xsl:value-of select="name"/> is located in 
  <xsl:value-of select="city"/>, <xsl:value-of select="state"/>.</b>
</xsl:template>

The result will be something like:

<b>SIUC is located in Carbondale, Illinois.</b>

<xsl:text> is located in </xsl:text>. 

This provides explicit control over how whitespace and linefeeds are treated.

<xsl:value-of> copies the value of something in the XML source tree to the result tree. In this case, the current node is <school>, so <xsl:value-of select="name"/> selects the text content of the <name> element contained within <school>. This is the simplest usage of XPath, which will be introduced shortly. XPath is not limited to the current node, so it can also be used to locate elements in other parts of the source document. It can even select attributes, processing instructions, or anything else that can occur in XML.

2.2.3. Built-in Template Rules

The first rule allows recursive processing to continue in case an explicit rule does not match the current node or the root node:

<xsl:template match="*|/">
  <xsl:apply-templates/>
</xsl:template>

This template matches all elements (*) and the root node (/), i.e., the document itself. It will not match processing instructions, comments, attributes, or text. The <xsl:apply-templates/> causes all children that are not attribute nodes or processing instruction nodes to be processed.

The second built-in rule is identical to the first, except it applies to each mode used in the stylesheet:

<xsl:template match="*|/" mode="m">
  <xsl:apply-templates mode="m"/>
</xsl:template>

Template modes are discussed in the next chapter, so we will not go into details here. The third built-in rule simply copies all text and attribute nodes to the result tree:

<xsl:template match="text( )|@*">
  <xsl:value-of select="."/>
</xsl:template>

And finally, the built-in rule for processing instructions and comments does nothing. This is why comments and processing instructions in the input XML data do not automatically show up in the result tree:

<xsl:template match="processing-instruction()|comment( )"/>

2.2.4. A Skeleton Stylesheet

<xsl:template match="/">
...content
</xsl:template>

Deciding how to modularize the stylesheet is a subjective process. One suggestion is to look for moderately sized chunks of XML data repeated numerous times throughout a document. For example, a <customer> element may contain a name, address, and phone number. Creating a template that matches "customer" is probably a good idea. You may even want to create another template for the <name> element, particularly if the name is broken down into subelements, or if the name is reused in other contexts such as <employee> and <manager>.

When you need to produce HTML tables or unordered lists in the result tree, two templates (instead of one) can make the job very easy. The first template will produce the <table> or <ul> element, and the second will produce each table row or list item. The following fragment illustrates this basic pattern:

<!-- the outer template produces the unordered list -->
<!-- (note: plural 'customers') -->
<xsl:template match="customers">
  <ul>
    <xsl:apply-templates select="customer"/>
  </ul>
</xsl:template>

<!-- the inner template is repeated for each customer -->
<xsl:template match="customer">
  <li><xsl:value-of select="name"/></li>
</xsl:template>