Indexes by means of XSLT 17 March 2006

Initial data sample

<?xml version="1.0" encoding="UTF-8"?>
<list>
	<item>Foster</item>
	<item>Watson</item>	
	<item>Campbell</item>
	<item>Adams</item>
	. . .
	<item>Elkin</item>
	<item>Cooper</item>
	<item>Enfield</item>
</list>

Template alpha-indexes.xsl has some features of particular interest that deserve closer attention.

All inner templates must be capable of processing random nodes. An appropriate XPath expression takes care of it:

<xsl:template match="* | @*" mode="column-indexes">
	<!-- Inner template script -->
</xsl:template>

Generating alphabetical blocks
Before arranging the nodes into columns we need alphabetical blocks. Lets use the Muenchian method to group the data (this is where the above mentioned key-name comes in handy).

<xsl:variable 
	name="blocks"
	select="$nodelist[generate-id(.) = 
		generate-id(key($key-name, substring(., 1, 1)))]"
/>

What does the trick is that generate-id function, if applied to a set of nodes, generates value only for the first node. So, we end up with a number of nodes based on first letter which is just what’s required for further steps.

Rows filled horizontally
In order to create the index rows we can go through the generated blocks checking if the current block position is a multiple of the number of columns. If it is, then a new row is generated.

<xsl:for-each select="$blocks">				
	<xsl:sort select="." />	
	<xsl:if test="(position() - 1) mod $count-columns = 0">
		<!-- Generating rows -->			
	</xsl:if>
</xsl:for-each>

I’d like to explain why I use the for-each outer loop instead of direct call on the row with specified predicate. The thing is that the initial data is unsorted, whereas we need to know the block position in a sorted set. So we first do the sorting, and then check the position.

Columns filled vertically
This task is a little more complex than the previous one. To arrange a set of nodes into columns we need to count how many blocks would make a complete column and check the current block’s position. If the position is a multiple of the number of blocks in a complete column, then a new column is generated.

<xsl:variable name="blocks-per-column" select="ceiling(count() div $count-columns)" />	
<xsl:for-each select="$blocks">				
	<xsl:sort select="." />
	<xsl:if test="(position() - 1) mod $blocks-per-column = 0">
		<!-- Generating columns -->
	</xsl:if>
</xsl:for-each>

However, it’s not that simple. If the task is to divide 12 blocks into 5 columns. The number of blocks in a complete column would be 3, and the whole set of blocks would fit into 4 columns which conflicts with the task. For this reason we need to generate additional columns when necessary. The script that arranges the blocks realizing this approach is rather lengthy, so it’s not included in this article.

Moreover, the template for generating columns has to count how many blocks are to appear in each of the columns (to be able to pass that number to the next template responsible for generating blocks in the column).

Number of blocks in a column filled vertically
The task is fairly easy—the call-template communicates the position of the first block (start-position) and the number of blocks in the column (blocks-per-this-column). Then, going through the blocks like before we can generate the blocks we need.

<xsl:for-each select="$blocks">
	<xsl:sort select="." />
	<xsl:if test="(position() &gt;= $start-position) and (position() &lt; $end-position)">
		<!-- Generating block -->
	</xsl:if>
</xsl:for-each>

Creating block contents
It’s another time the key-name is used.

<xsl:apply-templates select="key($key-name, substring(., 1, 1))" mode="item-indexes">
	<xsl:sort select="." />
</xsl:apply-templates>