Recursive XSL Templates

Recursion in XSL

XSL is a declarative programming language. Variables, once declared, cannot be reassigned. It is often difficult for programmers coming from a procedural languages background to do advanced tasks. By using XSL, you can solve complex problems that at first glance often seem to be difficult or impossible. In this brief, I will demonstrate the recursive nature of templates. In a typical case of a product catalog display, the requirement is to display the product details in each cell, and number of columns should be selectable by the user. A sample XML file is listed below:

<data>
<product name="Heine HKL with trolleystand"
         price="230.45"
         weight="34.4kg" />
<product name="Universal clamp and Projector"
         price="670.45"
         weight="10.64kg" />
<product name="Examination Lamp, Universal Mount"
         price="25.45"
         weight="1.08kg" />
<product name="Provita Examination Lamp, Mobile Base"
         price="215.45"
         weight="1.4kg" />
<product name="35Watt Flexible Arm Light to fit Rail system"
         price="130.45"
         weight="11.67kg" />
.
.
.
</data>

Assume that you get the above from a business component. Each element row corresponds to a product whose attributes are comprised of product-specific data. Each product, along with its details, will be rendered in a single cell. The number of columns should be definable at runtime. The following is the brief XSL that does the rendering:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0"
   xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:template match="/">
      <xsl:param name="numCols" select="3"/>
      <table cellpadding="0" cellspacing="5" border="0">
         <xsl:call-template name="renderColumns">
            <xsl:with-param name="listrows" select="//product"/>
            <xsl:with-param name="startindex" select="1"/>
            <xsl:with-param name="numofCols" select="$numCols"/>
         </xsl:call-template>
      </table>
   </xsl:template>

   <xsl:template name="renderColumns">
      <xsl:param name="listrows" />
      <xsl:param name="startindex"/>
      <xsl:param name="numofCols"/>
      <xsl:if test="count($listrows) > 0">
         <tr>
            <xsl:apply-templates select="$listrows[position()
               >= $startindex and position()
               < ($startindex+$numofCols)]" mode="rows">
            </xsl:apply-templates>
         </tr>
         <xsl:call-template name="renderColumns">
            <xsl:with-param name="listrows"
                 select="$listrows[position()
                 >= $startindex+$numofCols]"/>
            <xsl:with-param name="startindex"
                 select="$startindex"/>
               <xsl:with-param name="numofCols" select="$numofCols"/>
         </xsl:call-template>
      </xsl:if>
   </xsl:template>

   <xsl:template match="node()" mode="rows">
      <td nowrap="true">
         <table style="width:100%;border-right: thin solid;
                       border-top: thin solid; border-left: thin solid;
                       border-bottom: thin solid;">
            <xsl:apply-templates select="@*"/>
         </table>
      </td>
   </xsl:template>

   <xsl:template match="@*">
      <tr>
         <td style="font-size: larger; text-transform: uppercase;
                    background-color: gainsboro">
            <xsl:value-of select="name()"/>
         </td>
         <td>
            <xsl:value-of select="."/>
         </td>
      </tr>
   </xsl:template>
</xsl:stylesheet>

Explanation:

<xsl:template match="/">
   <xsl:param name="numCols" select="3"/>

As a C or C++ programmer organizes and reuses the code by using functions or object methods, in XSL you can organize code by using templates. The code above is the root template that will be invoked by the XSLT processor. You declare a parameter by using xsl:param, whose name is numCols. The user can pass this parameter; if the user does not supply any value in this parameter, by default it will have the value of 3. This variable will specify the number of columns to be rendered.

<xsl:call-template name="renderColumns">
   <xsl:with-param name="listrows" select="//product"/>
   <xsl:with-param name="startindex" select="1"/>
   <xsl:with-param name="numofCols" select="$numCols"/>
</xsl:call-template>

You call the renderColumns template, to which you pass three parameters. In listrows, you select all product elements. startindex signifies the starting index, and numofCols will control the number of rows to be rendered.

<xsl:template name="renderColumns">
   <xsl:param name="listrows" />
   <xsl:param name="startindex"/>
   <xsl:param name="numofCols"/>
   <xsl:if test="count($listrows) > 0">
      <tr>
         <xsl:apply-templates select="$listrows[position()
            >= $startindex and position()
            < ($startindex+$numofCols)]" mode="rows">
         </xsl:apply-templates>
      </tr>
      <xsl:call-template name="renderColumns">
         <xsl:with-param name="listrows"
                         select="$listrows[position()
                         >= $startindex+$numofCols]"/>
            <xsl:with-param name="startindex"
                            select="$startindex"/>
            <xsl:with-param name="numofCols" select="$numofCols"/>
      </xsl:call-template>
   </xsl:if>
</xsl:template>

In XSL template renderColumns, you select elements whose position will be greater than or equal to the starting index and whose position is less than or equal to the sum of startindex and numofcols. After rendering this subset of elements, you recursively call renderColumns by selecting a subset of elements whose position is greater than the sum of startindex and numofCols, which are already rendered. To exit this recursive loop, you have a test condition at the start; it checks for the count of elements in the listrows variable. Because you are selecting only those elements that are yet to be rendered while calling recursively, sa et of nodes by each call will be reduced by the number of elements rendered. To rendering rows, in this call template you using the following template:

<xsl:template match="node()" mode="rows">
   <td nowrap="true">
      <table style="width:100%; border-right: thin solid;
                    border-top: thin solid; border-left: thin solid;
                    border-bottom: thin solid;">
         <xsl:apply-templates select="@*"/>
      </table>
   </td>
</xsl:template>

In which you convert attribute nodes into elements and call another template:

<xsl:template match="@*">
   <tr>
      <td style="font-size: larger; text-transform: uppercase;
                 background-color: gainsboro">
         <xsl:value-of select="name()"/>
      </td>
      <td>
         <xsl:value-of select="."/>
      </td>
   </tr>
</xsl:template>

This does the job of rendering the product details in a cell.

Conclusion

Even though variables are constant throughout the lifetime of a variable in XSL, you can achieve things that are at first glance looks not possible due to the declarative nature of XSL. Upon a close look and thinking in a declarative manner, you can solve the problem.

</xsl:template>

<xsl:template name="renderColumns">
   <xsl:param name="listrows" />
   <xsl:param name="startindex"/>
   <xsl:param name="numofCols"/>
   <xsl:if test="count($listrows) > 0">
   <tr>
      <xsl:apply-templates select="$listrows[position()
           >= $startindex and position()
           < ($startindex+$numofCols)]" mode="rows">
      </xsl:apply-templates>
   </tr>
      <xsl:call-template name="renderColumns">
        <xsl:with-param name="listrows"
                        select="$listrows[position()
                        >= $startindex+$numofCols]"/>
          <xsl:with-param name="startindex" select="$startindex"/>
          <xsl:with-param name="numofCols" select="$numofCols"/>
      </xsl:call-template>
   </xsl:if>
</xsl:template>

<xsl:template match="node()" mode="rows">
   <td nowrap="true">
      <table style="width:100%;border-right: thin solid; border-top:
                    thin solid; border-left: thin solid;
                    border-bottom: thin solid;">
         <xsl:apply-templates select="@*"/>
      </table>
   </td>
</xsl:template>

<xsl:template match="@*">
   <tr>
      <td style="font-size: larger; text-transform: uppercase;
                 background-color: gainsboro">
         <xsl:value-of select="name()"/>
      </td>
      <td>
         <xsl:value-of select="."/>
      </td>
   </tr>
</xsl:template>
</xsl:stylesheet>

Explanation:

<xsl:template match="/">
   <xsl:param name="numCols" select="3"/>

As a C or C++ programmer organizes and reuses the code using by functions or object methods, in XSL you can organize code by using templates. The code above is the root template that will be invoked by the XSLT processor. You declare a parameter by using the xsl:param, whose name is numCols. The user can pass this parameter. If the user does not supply any value in this parameter, by default it will have the value of 3. This variable will specify the number of columns to be rendered.

<xsl:call-template name="renderColumns">
   <xsl:with-param name="listrows" select="//product"/>
   <xsl:with-param name="startindex" select="1"/>
   <xsl:with-param name="numofCols" select="$numCols"/>
</xsl:call-template>


About the Author

Kiran Kumar

I am presently working with Intelligroup. Had 5+ yrs of experience on various technologies.

Comments

  • There are no comments yet. Be the first to comment!

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Organizations are increasingly gravitating toward mobile-first application development as they assess the need to revamp their application portfolios to support touch computing and mobility. Consumerization has brought higher expectations for application usability along with the mobile devices themselves. Enterprises are increasingly shifting their new application acquisitions and development efforts toward mobile platforms. With this backdrop, it is natural to expect application platform vendors to invest in …

  • By now you've likely heard of Agile development and building products in small incremental pieces, so you can get real feedback along the way. In fact, you may even be considering using Agile on your next project. But where do you start? Agile can take a lot of forms, such as Scrum or Kanban. Each form has advantages and disadvantages, but both will help your team get the right feedback they need to build great products. Read this white paper to find out which one is right for you.

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date