XSLT 2.0 and XPath 2.0 Programmer's Reference, 4th Edition (697 page)

Example: Aggregating a List of Numbers

The following example uses a recursive template to process a whitespace-separated list of numbers.

Input

Suppose you have a string that holds a white-space-separated list of numbers, for example
(12,
34.5,
18.2,
5)
, and you want to replace this with a cumulative sequence
(12,
46.5,
64.7,
69.7)
in which each number is the sum of the previous values. An example of an application that might need to do this is a billing application, where the input sequence contains the values of individual transactions, and the output sequence shows a running balance.

This could be done with an XPath expression such as follows:

However, this involves
n
2
/2 additions, which gets more and more expensive as the size of the sequence increases. It's reasonable to look for a solution that is more scalable than this.

For the sake of an example, this is the entire content of the document,
number-list.xml
.

We'll suppose that there is a schema that validates this as a sequence of
xs:decimal
values, so we don't need to be concerned with the parsing of the string; we can simply access the typed value of the element as a sequence.

Schema

The schema used to validate this trivial source document is
number-list.xsd
.

Stylesheet

Here's the recursive stylesheet (in file
number-total.xsl
):

To run this, you need a schema-aware XSLT2.0 processor, such as Altova or Saxon-SA. (With Saxon-SA, remember to set
-val:strict
on the command line. With Altova, the source document needs to contain a reference to the schema.)

Notice how closely the function
f:total-numbers
mirrors the pseudocode structure given earlier.

If the supplied list is empty, the function returns nothing (an empty sequence).

The first time the function is called, it returns the value of the first item in the sequence (obtained by adding the value of this item to the running total, which is initialized to zero). It then calls itself to process the rest of the list and returns the result of this processing.

Each subsequent time the function is called, it processes the first value in what's left of the input sequence, adds this to the running total that was supplied as a parameter, outputs this value, and then calls itself to process the tail of the sequence.

Eventually, the function will call itself with an empty sequence as the argument, at which point it returns, unwinding the entire stack of function calls.

Output

Example: Using Interleaved Structures

XML makes it very easy to represent hierarchic structures, such as the chapters, sections, and paragraphs of a book. But what do you do when there are structures that are nonhierarchic? An example is the text of a play: one way of splitting the text is according to who is speaking, and another way is to follow the meter of the verse. The problem is that lines of verse aren't neatly nested inside speeches, and speeches aren't nested inside lines of verse: the two structures are interleaved. The usual solution to this problem is to use the hierarchic XML tagging to represent one of the structures (say the speeches) and to use empty element tags to mark the boundaries in the other structure.

(Another design approach is referred to as
standoff markup
: the markup for either or both of the structures is held separately from the text itself, using XPointer references to identify the text to which it relates. Markup of parallel structures is a complicated subject, of great concern to linguistics scholars, and many academic papers are devoted to the topic.)

Input

This example (
scene4-3.xml
) is an extract from Shakespeare's
Othello
, Act IV, Scene 3. I have departed from Jon Bosak's markup to show the line endings as they are given in the Arden Shakespeare edition.

Output

Typically, a printed edition of this play is formatted with the kind of layout shown in
Figure 17-4
, in which lines that are split across multiple speeches are indented to show their relationship.

Figure 17-4

Achieving this format is not easy (especially details such as the omission of a new line if the indented text fits on the same line as the speaker's name), and it certainly requires a computational stylesheet to achieve it. Rather than attempt this, I will tackle a simpler problem, which is to invert the structure so that the primary XML hierarchy shows the lines, and the start of each speech is tagged by an empty element.

Stylesheet

I tackle this by processing the text sequentially, using a recursive template. The structure I have followed below is a two-phase approach. The first phase flattens the structure so that both the speech boundaries and the line boundaries are represented by empty elements, appearing as siblings of the text nodes. The result of the first phase is held in the variable
$flat
. This variable holds a sequence of (parentless) element and text nodes. The second phase then adds the hierarchic structure of

elements containing the text and

nodes.

Here is the top-level logic of the stylesheet
invert.xsl
. Note how the second phase starts by processing only the first node in the sequence
$flat
. after the initial

.

Now the template rules for the first phase, the flattening phase. This is handled by a single rule which processes a

by first creating a

element containing the name of the speaker and then copying all the nodes from the original except for the

element. We are assuming here that each speech has only one speaker.

We now have a flat structure containing

elements, empty

elements, text nodes, and

elements. Phase 2 is structured so a template rule is called once for each node in the sequence
$flat
. In each case, this template rule calls

to process the next node in the sequence (and thus, by implication, the rest of the sequence beyond). I refer to this style of processing as
sibling recursion
. When an

element is encountered, a new

element is written to the result tree, and the following elements generate children of this

element. When any other kind of node is encountered, it is simply copied to the result tree at the current level.

The expression
following-sibling::node()[1][not(self::NL)]
selects the next sibling node, provided it is not an

element; if the next sibling is an

element, it selects an empty sequence.

There is very little that is specific to XSLT 2.0 in this stylesheet, with the exception of the sequence of nodes used as an intermediate variable. The second phase could have been written without explicit recursion, using

, but in my view the recursive solution in this case is not really any more difficult.

This stylesheet also demonstrates that recursive processing of a sequence can often be carried out very elegantly, using

. I find that there is a tendency when writing recursive code to reach straight for

(or, in XSLT 2.0,

) when

can often do the job far better.

Superficially, the logic of this stylesheet doesn't bear much resemblance to the prototypical head/tail recursive structure described earlier. But in fact, this is precisely the underlying structure. The
match=“SCENE”
template selects all the

elements, each one implicitly identifying a sequence that starts with that

and continues up to the next

. The processing of this sequence is split between the two
mode=“phase2”
template rules, each of which has the structure “handle this node, then recursively process the next sibling”. Processing the next sibling here is effectively processing the remainder of the list. The test for the terminating condition is implicit, because

does nothing when the selected node sequence is empty.