XSLT显示序列号

Question

My input XML consists of the following,

<root>
    <entry>
        <type>U</type>
        <value>111</value>
    </entry>
    <entry>
        <type>X</type>
        <value>222</value>
    </entry>
    <entry>
        <type>E</type>
        <value>333</value>
    </entry>
    <entry>
        <type>Q</type>
        <value>444</value>
    </entry>
</root>

Output i required, <ROOT> <ENTRY> <SLNO>1</SLNO> <VALUE>111</VALUE> </ENTRY> <ENTRY> <VALUE>222</VALUE> </ENTRY> <ENTRY> <VALUE>333</VALUE> </ENTRY> <ENTRY> <SLNO>2</SLNO> <VALUE>444</VALUE> </ENTRY> </ROOT>

I need to parse all the records, but need to put serial number for records whose type is not X and E.

I have written a for-each to for the same and used ´position()´ to display a serial number with condtion for type E and X. So I'm getting serial number as 1, 4 instead of 1, 2 because of ´postion()´.

I thought of creating a global variable and increment it inside my if block, but XSLT 1.0 will not allow to increment variable values.

How can I achieve this?

My sample XSL code is asl follows,

<xsl:for-each select="/ROOT/ENTRY">
    <xsl:if test="(TYPE != 'X') and (TYPE != 'E')">             
        <xsl:text><![CDATA[<SLNO>]]></xsl:text>
        <xsl:number value="position()"/>
        <xsl:text><![CDATA[</SLNO>]]></xsl:text>
    </xsl:if>
    <!-- Printing remaining values -->
</xsl:for-each>

Please help.

Answer 1

Instead of using position(), you could count the number of preceding type elements in your XML

<xsl:value-of select="count(preceding::type[. != 'X' and . != 'E']) + 1" />

Additionally, you can simplify your current XSLT by matching the type element directly, rather than the entry element, and then just replace it with the new slno element.

<xsl:template match="type[. != 'X' and . != 'E']">

For example, try the following XSLT

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="xml" indent="yes"/>

   <xsl:template match="type[. != 'X' and . != 'E']">
      <slno><xsl:value-of select="count(preceding::type[. != 'X' and . != 'E']) + 1" /></slno>
   </xsl:template>

   <xsl:template match="type" />

   <xsl:template match="@*|node()">
      <xsl:copy>
         <xsl:apply-templates select="@*|node()"/>
      </xsl:copy>
   </xsl:template>
</xsl:stylesheet>

When applied to your sample XML, the following is output

<root>
   <entry>
      <slno>1</slno>
      <value>111</value>
   </entry>
   <entry>
      <value>222</value>
   </entry>
   <entry>
      <value>333</value>
   </entry>
   <entry>
      <slno>2</slno>
      <value>444</value>
   </entry>
</root>

Note, I am using all lower-case element names here. I wasn't sure from your question if you wanted to translate them into upper-case or not.

Answer 2

The accepted answer is a good one, except that the implemented algorithm has O(N^2) (quadratic) time complexity and executes very slow on large inputs .

Here is transformation with linear-time-complexity O(N):

<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output omit-xml-declaration="yes" indent="yes"/>
 <xsl:strip-space elements="*"/>

 <xsl:template match="node()|@*">
  <xsl:param name="pCount" select="0"/>
  <xsl:copy>
   <xsl:apply-templates select="node()[1]|@*">
     <xsl:with-param name="pCount" select="$pCount"/>
   </xsl:apply-templates>
  </xsl:copy>
  <xsl:apply-templates select="following-sibling::node()[1]">
     <xsl:with-param name="pCount" select="$pCount"/>
  </xsl:apply-templates>
 </xsl:template>

 <xsl:template match="entry[not(contains('EX', type))]">
  <xsl:param name="pCount" select="0"/>

  <xsl:copy>
   <slno><xsl:value-of select="$pCount+1"/></slno>
   <xsl:apply-templates select="node()[1]|@*">
     <xsl:with-param name="pCount" select="$pCount+1"/>
   </xsl:apply-templates>
  </xsl:copy>
  <xsl:apply-templates select="following-sibling::node()[1]">
     <xsl:with-param name="pCount" select="$pCount+1"/>
  </xsl:apply-templates>
 </xsl:template>

 <xsl:template match="type">
   <xsl:param name="pCount" select="0"/>
   <xsl:apply-templates select="following-sibling::node()[1]">
     <xsl:with-param name="pCount" select="$pCount+1"/>
   </xsl:apply-templates>
 </xsl:template>
</xsl:stylesheet>

When applied on the provided XML document:

<root>
    <entry>
        <type>U</type>
        <value>111</value>
    </entry>
    <entry>
        <type>X</type>
        <value>222</value>
    </entry>
    <entry>
        <type>E</type>
        <value>333</value>
    </entry>
    <entry>
        <type>Q</type>
        <value>444</value>
    </entry>
</root>

the wanted, correct result is produced:

<root>
   <entry>
      <slno>1</slno>
      <value>111</value>
   </entry>
   <entry>
      <value>222</value>
   </entry>
   <entry>
      <value>333</value>
   </entry>
   <entry>
      <slno>2</slno>
      <value>444</value>
   </entry>
</root>

Explanation :

1. Using and overriding the "fine-grained identity rule" . It bears its name due to the fact that templates are applied only to one node (in document order) at a time.

2. The "fine-grained identity rule" is modified to contain and pass a parameter $pCount , which contains the maximum current "serial number" reached so far.

3. This works without the need to return back the current serial number, because all entry elements are siblings.

4. The time complexity is linear, because there is no counting of all preceding siblings at every node, as done in the other answer.