analytics/bin/v4postprocessing.xslt

<?xml version="1.0" encoding="UTF-8"?>
<!--
/*****************************************************************************
 * Licensed Materials - Property of IBM 
 *
 * IBM Cognos Products: migv4
 *
 * (C) Copyright IBM Corp. 2003, 2011.
 *
 * US Government Users Restricted Rights - Use, duplication or disclosure
 * restricted by GSA ADP Schedule Contract with IBM Corp. 
 ****************************************************************************/
-->
<?xml-stylesheet type="text/xsl" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:fo="http://www.w3.org/1999/XSL/Format" 
xmlns:str="http://www.ora.com/XSLTCookbook/namespaces/strings" 
xmlns="http://developer.cognos.com/schemas/report/1/" 
xmlns:v4="http://developer.cognos.com/schemas/report/1/"
exclude-result-prefixes="xsl fo str v4">
	<xsl:output method="xml" version="1.0" encoding="UTF-8" omit-xml-declaration="yes"/>

	<!-- copy all children nodes -->
	<xsl:template match=" node() | @* | comment() | processing-instruction()">
	  	<xsl:copy>
			<xsl:apply-templates select="node() | @*"/>
	  	</xsl:copy>
	</xsl:template>
	
	<xsl:variable name="MSQ5" select="'Master_Section_Query5'"/>

	<!-- =============================================================================== -->
	<!-- resolve dangling data items directly in Master_Selection_Query5 -->
	
	<!-- preprocess Master Selection Query5 -->
	<xsl:template match="v4:BIQuery[ @name = $MSQ5 ]">
		<xsl:copy>
			<xsl:apply-templates select="@*"/>
			
			<xsl:for-each select="*">
				<xsl:choose>
					<!-- cube node -->
					<xsl:when test="local-name()='cube'">
						<xsl:copy>
							<xsl:apply-templates select="@*"/>
							
							<!-- get factList nodes -->
							<xsl:variable name="factListExists" select="v4:factList"/>
							
							<xsl:variable name="cubechildren" select="./*"/>
							<xsl:for-each select="$cubechildren">
								<xsl:choose>
									<!-- if factList node exists, copy existing items. then add new ones -->
									<xsl:when test="local-name()='factList'">
										<xsl:copy>
											<xsl:apply-templates select="@*"/>
											<xsl:apply-templates select="*"/>
											<xsl:call-template name="processExpressions"/>
											<xsl:call-template name="processQueryItemRef"/>
										</xsl:copy>
									</xsl:when>
									
									<xsl:when test="local-name()='dimension'">
										<xsl:if test="count($factListExists) &gt; 0">
											<xsl:copy>
												<xsl:apply-templates select="@*"/>
												<xsl:apply-templates select="node() | comment() | processing-instruction()"/>
											</xsl:copy>
										</xsl:if>

										<xsl:if test="count($factListExists) = 0">
											<xsl:copy>
												<xsl:apply-templates select="@*"/>
												
												<xsl:variable name="levels" select="v4:level"/>
												<xsl:for-each select="$levels">
													<xsl:choose>
														<xsl:when test="position() &lt; count($levels)">
															<xsl:copy-of select="."/>
														</xsl:when>
														<xsl:otherwise>
															<xsl:copy>
																<xsl:apply-templates select="node() | @* | comment() | processing-instruction()"/>
																<xsl:call-template name="processExpressions"/>
																<xsl:call-template name="processQueryItemRef"/>
															</xsl:copy>
														</xsl:otherwise>
													</xsl:choose>
												</xsl:for-each>
											</xsl:copy>
										</xsl:if>
										
									</xsl:when>
									
									<!-- for all other nodes, copy them -->
									<xsl:otherwise>
										<xsl:apply-templates select="."/>
									</xsl:otherwise>
								</xsl:choose>
							</xsl:for-each>
							
						</xsl:copy>
					</xsl:when>
					
					<!-- tabularModel node -->
					<xsl:when test="local-name()='tabularModel'">
						<xsl:copy>
						
							<!-- copy all existing attributes and nodes -->
							<xsl:apply-templates select="node() | @* | comment() | processing-instruction()"/>
							
							<!-- add new dataItems for expressions -->
							<xsl:call-template name="processExpressions">
								<xsl:with-param name="nodename" select="'tabularModel'"/>
							</xsl:call-template>
							<!-- add new dataItems for queryItemRefs -->
							<xsl:call-template name="processQueryItemRef">
								<xsl:with-param name="nodename" select="'tabularModel'"/>
							</xsl:call-template>
						</xsl:copy>
					</xsl:when>
					
					<!-- copy all other nodes -->
					<xsl:otherwise>
						<xsl:copy>
							<xsl:apply-templates select="node() | @* | comment() | processing-instruction()"/>
						</xsl:copy>
					</xsl:otherwise>
					
				</xsl:choose>
			</xsl:for-each>
			
		</xsl:copy>
	</xsl:template>
	
	<!-- Process all query item references under all layout elements that refer directly to Master Section Query5 -->
	<xsl:template name="processQueryItemRef">
		<xsl:param name="nodename" select="'factList'"/>
		
		<xsl:variable name="queryItemRefs" select="//v4:layout//*[ @refQuery = $MSQ5 ]//v4:queryItemRef"/>
		<xsl:for-each select="$queryItemRefs">

			<!-- only process the direct children of master query5 -->
			<xsl:if test="count(./ancestor::*[@refQuery]) = 1">
			
				<!-- check if the same quertItemRef was processed already -->
				<xsl:variable name="curpos" select="position()"/>
				<xsl:variable name="refItem" select="@refItem"/>
				<xsl:variable name="existed">
					<xsl:for-each select="$queryItemRefs">
						<xsl:if test="position() &lt; $curpos">
							<xsl:if test="count(./ancestor::*[@refQuery]) = 1 and @refItem = $refItem">
								<xsl:value-of select="'1'"/>
							</xsl:if>
						</xsl:if>
					</xsl:for-each>
				</xsl:variable>
			
				<xsl:if test="not (contains($existed, '1'))">
					<!-- add new items to factList -->
					<xsl:if test="$nodename = 'factList'">
						<xsl:call-template name="findFactList">
							<xsl:with-param name="queryname" select="@refItem"/>
						</xsl:call-template>
					</xsl:if>
					<!-- add new dataItems to tabularModel -->
					<xsl:if test="$nodename = 'tabularModel'">
						<xsl:call-template name="findDataItem">
							<xsl:with-param name="queryname" select="@refItem"/>
						</xsl:call-template>
					</xsl:if>
				</xsl:if>
			</xsl:if>
		</xsl:for-each>
	</xsl:template>

	<!-- Process all expressions under all layout elements that refer directly to Master Section Query5 -->
	<xsl:template name="processExpressions">
		<xsl:param name="nodename" select="'factList'"/>
		
		<xsl:variable name="expressions" select="//v4:layout//*[ @refQuery = $MSQ5 ]//v4:expression"/>
		<xsl:for-each select="$expressions">
			<xsl:if test="count(./ancestor::*[@refQuery]) = 1">
				<xsl:call-template name="processExpression">
					<xsl:with-param name="nodename" select="$nodename"/>
					<xsl:with-param name="expression" select="."/>
					<xsl:with-param name="expressions" select="$expressions"/>
					<xsl:with-param name="curpos" select="position()"/>
				</xsl:call-template>
			</xsl:if>
		</xsl:for-each>
	</xsl:template>

	<!-- process one expression -->
	<xsl:template name="processExpression">
		<xsl:param name="nodename" select="'factList'"/>
		<xsl:param name="expression"/>
		<xsl:param name="expressions"/>
		<xsl:param name="curpos" select="1"/>
		
		<xsl:variable name="qiName" select="substring-after(substring-before($expression, ']'), '[')"/>
		<xsl:if test="string-length($qiName) &gt; 0 and $qiName != ''">

			<!-- check if the same quertItemRef was processed already -->
			<xsl:variable name="existed">
				<xsl:for-each select="$expressions">
					<xsl:if test="position() &lt; $curpos">
						<xsl:if test="count(./ancestor::*[@refQuery]) = 1 and contains(./text(), concat('[',$qiName,']'))">
							<xsl:value-of select="'1'"/>
						</xsl:if>
					</xsl:if>
				</xsl:for-each>
				<xsl:if test="contains( substring-before($expressions[$curpos]/text(),$expression), concat('[',$qiName,']'))">
					<xsl:value-of select="'1'"/>
				</xsl:if>
			</xsl:variable>

			<xsl:if test="not (contains( $existed, '1'))">
				<xsl:if test="$nodename = 'factList'">
					<!-- add a new item to factList -->
					<xsl:call-template name="findFactList">
						<xsl:with-param name="queryname" select="$qiName"/>
					</xsl:call-template>
				</xsl:if>
				<xsl:if test="$nodename = 'tabularModel'">
					<!-- add a new dataItem to tabularModel -->
					<xsl:call-template name="findDataItem">
						<xsl:with-param name="queryname" select="$qiName"/>
					</xsl:call-template>
				</xsl:if>
			</xsl:if>
		</xsl:if>
		<xsl:if test="contains(substring-after($expression, ']'), '[')">
		<!-- recursive call to process remainder of $expression -->
			<xsl:call-template name="processExpression">
				<xsl:with-param name="nodename" select="'factList'"/>
				<xsl:with-param name="expression" select="substring-after($expression, ']')"/>
				<xsl:with-param name="expressions"/>
				<xsl:with-param name="curpos" select="$curpos"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>
	
	<xsl:template name="findFactList">
		<xsl:param name="queryname"/>
		<xsl:variable name="item" select="//v4:BIQuery//v4:cube//v4:item[ @refItem = $queryname ]"/>
		<xsl:if test="count($item) &gt; 0">
			<xsl:variable name="parentquery" select="$item/ancestor::v4:BIQuery[ @name = $MSQ5 ]"/>
			<xsl:if test="count($parentquery) = 0">
				<xsl:copy-of select="$item[1]"/>
			</xsl:if>
		</xsl:if>
	</xsl:template>
	
	<xsl:template name="findDataItem">
		<xsl:param name="queryname"/>
		<xsl:variable name="item" select="//v4:BIQuery//v4:tabularModel/v4:dataItem[ @name = $queryname ]"/>
		<xsl:if test="count($item) &gt; 0">
			<xsl:variable name="parentquery" select="$item/ancestor::v4:BIQuery[ @name = $MSQ5 ]"/>
			<xsl:if test="count($parentquery) = 0">
				<xsl:copy-of select="$item[1]"/>
			</xsl:if>
		</xsl:if>
	</xsl:template>

	<!-- =============================================================================== -->
	<!-- BUG FIX 488862
			Apparently, customers are somewhat miffed that all query item references on their cover pages and page
		headers / footers are being translated into '[Data item out of Query Scope: ... ]' text items. This section attempts
		to assign the most appropriate query to the page so that these dangling data items suddenly have scope.
			This fix does not address all dangling data items. In the case where data items from two or more queries are
		found on the cover page or page header/footer, this algorithm will select the query that contains the greatest
		number of these data items. All other data items will be translated into text items as above.
	  -->
	<xsl:template match="v4:pageSet/v4:page">
		<!-- This template examines the layout page contents for dangling data items.
			If found, it sets @refQuery attribute to name of most appropriate query.
		  -->
		<xsl:copy>
			<xsl:copy-of select="@*"/>
			<xsl:choose>
				<xsl:when test="@refQuery">
					<!-- Cannot replace existing refQuery attribute -->
				</xsl:when>
				<xsl:when test="ancestor::v4:pageSet/@refQuery">
					<!-- Copy refQuery from pageSet -->
					<xsl:attribute name="refQuery"><xsl:value-of select="ancestor::v4:pageSet/@refQuery"/></xsl:attribute>
				</xsl:when>
				<xsl:when test=".//v4:queryItemRef[count(ancestor::v4:*/@refQuery) = 0] or .//v4:expression[count(ancestor::v4:*/@refQuery) = 0]">
					<!-- Add  refQuery attribute for dangling data items -->
					<!--DBG- -><xsl:call-template name="findBestQuery"/-->
					<xsl:variable name="bestQuery"><xsl:call-template name="findBestQuery"/></xsl:variable>
					<xsl:if test="$bestQuery != ''">
						<xsl:attribute name="refQuery"><xsl:value-of select="$bestQuery"/></xsl:attribute>
					</xsl:if>
				</xsl:when>
				<xsl:otherwise>
					<!-- Cannot find any dangling items: therefore, nothing to do! -->
				</xsl:otherwise>
			</xsl:choose>

			<!-- Process remainder of page -->
			<xsl:apply-templates/>
		</xsl:copy>
	</xsl:template>
	<!-- =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  =  = -->
	<xsl:template match="v4:promptPageList/v4:page">
		<!-- This template examines the prompt page contents for dangling data items.
			If found, it sets @refQuery attribute to name of most appropriate query.
		  -->
		<xsl:copy>
			<xsl:copy-of select="@*"/>
			<xsl:choose>
				<xsl:when test="@refQuery">
					<!-- Cannot replace existing refQuery attribute -->
				</xsl:when>
				<xsl:when test=".//v4:queryItemRef[count(ancestor::v4:*/@refQuery) = 0] or .//v4:expression[count(ancestor::v4:*/@refQuery) = 0]">
					<!-- Add  refQuery attribute for dangling data items -->
					<xsl:variable name="bestQuery"><xsl:call-template name="findBestQuery">
						<xsl:with-param name="queryList" select=".//v4:*/@refQuery"/>
					</xsl:call-template></xsl:variable>
					<xsl:if test="$bestQuery != ''">
						<xsl:attribute name="refQuery"><xsl:value-of select="$bestQuery"/></xsl:attribute>
					</xsl:if>
				</xsl:when>
				<xsl:otherwise>
					<!-- Cannot find any dangling items: therefore, nothing to do! -->
				</xsl:otherwise>
			</xsl:choose>

			<!-- Process remainder of page -->
			<xsl:apply-templates/>
		</xsl:copy>
	</xsl:template>
	<!-- === === === === === === === === === === === === === === === -->
	<xsl:template name="findBestQuery">
		<!-- queries referenced on page -->
		<xsl:param name="queryList" select="ancestor::v4:pageSet//v4:*/@refQuery"/>
		<!-- dangling data items -->
		<xsl:param name="queryItemRefs" select=".//v4:queryItemRef[count(ancestor::v4:*/@refQuery) = 0]/@refItem"/>
		<!-- dangling data items in expressions -->
		<xsl:param name="expressions" select=".//v4:expression[count(ancestor::v4:*/@refQuery) = 0]"/>
		
		<!-- This template examines all queries referenced in the page set to determine the most appropriate query for
			the refQuery attribute. The 'best query' is the BIQuery that contains the most items that are referenced in
			the queryItemRefs[] and expressions[] collections. Each query is examined by recursive TestBestQuery
			template.
		   -->
		<xsl:if test="$queryList">
			<!-- Report expressions contain zero, one or many query item references. Extract these references by
				perusing the syntax of the report expression (see 'extractExprItemRefs' template).
			  -->
			<xsl:variable name="exprItemRefs">
				<xsl:call-template name="extractExprItemRefs">
					<xsl:with-param name="expressions" select="$expressions"/>
				</xsl:call-template>
			</xsl:variable>
			<!-- Initial call to recursive TestBestQuery routine.
				It should return the name of the most appropriate query to resolve dangling data items.
			  -->
			<!--DBG- -><xsl:comment>queryList = '<xsl:value-of select="$queryList"/>'</xsl:comment-->
			<!--DBG- -><xsl:comment>queryItemRefs = '<xsl:value-of select="$queryItemRefs"/>'</xsl:comment-->
			<!--DBG- -><xsl:comment>exprItemRefs = '<xsl:value-of select="$exprItemRefs"/>'</xsl:comment-->
			<xsl:call-template name="TestBestQuery">
				<xsl:with-param name="queryList" select="$queryList"/>
				<xsl:with-param name="queryItemRefs" select="$queryItemRefs"/>
				<xsl:with-param name="exprItemRefs" select="$exprItemRefs"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>
	<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
	<xsl:template name="TestBestQuery">
		<xsl:param name="queryList"/>	<!-- queries referenced on page -->
		<xsl:param name="queryItemRefs"/>	<!-- dangling data items -->
		<xsl:param name="exprItemRefs"/>	<!-- dangling data items in expressions -->
		<xsl:param name="bestQuery"/>	<!-- 'best query' as nominated (thus far) -->
		<xsl:param name="bestQueryCount" select="0"/>	<!-- count of data items in bestQuery: initialize to 0 -->
		<xsl:param name="queryIndex" select="1"/>	<!-- identifies index of current query in queryList[] -->

		<!-- This is a recursive routine that examines current query for items referenced in query item references and
			report expressions. If this count is greater than current count, it nominates current query as 'bestQuery',
			then examines remaining queries via recursive call. Returns name of 'bestQuery' as passed or nominated.
		   -->
		<xsl:choose>
			<xsl:when test="$queryIndex &lt;= count($queryList)">	<!-- list boundary test -->
				<!-- Processing query at queryList [ queryIndex ] -->
				<!-- name of current query -->
				<xsl:variable name="myQueryName" select="string($queryList[$queryIndex])"/>
				<!-- count of dangling data items that are found in the current query -->
				<xsl:variable name="myQueryCount">
					<xsl:call-template name="countQueryItems">
						<xsl:with-param name="myQueryItems" select="//v4:BIQuery[@name=$myQueryName]/v4:cube//v4:*[local-name() = 'item'  or  'dataItem' = local-name()]"/>
						<xsl:with-param name="queryItemRefs" select="$queryItemRefs"/>
						<xsl:with-param name="exprItemRefs" select="$exprItemRefs"/>
					</xsl:call-template>
				</xsl:variable>
					<!--DBG- -><xsl:call-template name="countQueryItems"-->
						<!--DBG- -><xsl:with-param name="myQueryItems" select="//v4:BIQuery[@name=$myQueryName]/v4:cube//v4:*[local-name() = 'item'  or  'dataItem' = local-name()]"/-->
						<!--DBG- -><xsl:with-param name="queryItemRefs" select="$queryItemRefs"/-->
						<!--DBG- -><xsl:with-param name="exprItemRefs" select="$exprItemRefs"/-->
					<!--DBG- -></xsl:call-template-->
				<!--DBG- -><xsl:comment>  queryList[<xsl:value-of select="$queryIndex"/>] = '<xsl:value-of select="$myQueryName"/>'</xsl:comment-->
				<!--DBG- -><xsl:comment>  queryCount = <xsl:value-of select="$myQueryCount"/></xsl:comment-->
				<xsl:choose>
					<xsl:when test="$bestQueryCount &lt; $myQueryCount">
						<!-- The current query contains more data items than the last query!
							Nominate this query as 'bestQuery', and process next query in list (in case it's even better).
						  -->
						<!--DBG- -><xsl:comment>  bestQuery[<xsl:value-of select="$myQueryCount"/>] = '<xsl:value-of select="$myQueryName"/>'</xsl:comment-->
						<xsl:call-template name="TestBestQuery">
							<xsl:with-param name="bestQuery" select="$myQueryName"/>	<!-- Name of this query -->
							<xsl:with-param name="bestQueryCount" select="$myQueryCount"/>	<!-- new count -->
							<xsl:with-param name="queryIndex" select="$queryIndex +1"/>	<!-- search next query -->
							<xsl:with-param name="queryList" select="$queryList"/>
							<xsl:with-param name="queryItemRefs" select="$queryItemRefs"/>
							<xsl:with-param name="exprItemRefs" select="$exprItemRefs"/>
						</xsl:call-template>
					</xsl:when>
					<xsl:when test="$queryIndex &lt; count($queryList)">
						<!-- There are still queries in the list to process: one of them might be better than current 'bestQuery'.
							Process next query in list, using $bestQuery as given
						  -->
						<xsl:call-template name="TestBestQuery">
							<xsl:with-param name="queryList" select="$queryList"/>
							<xsl:with-param name="queryItemRefs" select="$queryItemRefs"/>
							<xsl:with-param name="exprItemRefs" select="$exprItemRefs"/>
							<xsl:with-param name="bestQuery" select="$bestQuery"/>	<!-- passed query -->
							<xsl:with-param name="bestQueryCount" select="$bestQueryCount"/>	<!-- passed count -->
							<xsl:with-param name="queryIndex" select="$queryIndex +1"/>	<!-- search next query -->
						</xsl:call-template>
					</xsl:when>
					<xsl:otherwise>
						<!-- No more queries to process: Return name of Best Query as passed -->
						<xsl:value-of select="$bestQuery"/>
					</xsl:otherwise>
				</xsl:choose>
			</xsl:when>
			<xsl:otherwise>
				<!-- When this template was called, all queries had been processed.
					Return name of 'Best Query' as nominated.
				  -->
				<xsl:value-of select="$bestQuery"/>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>
	<!-- === === === === === === === === === === === === === === === -->
	<xsl:template name="extractExprItemRefs">
		<xsl:param name="exprItemRefs"/>	<!-- list of item references extracted from previous expressions -->
		<xsl:param name="expressions"/>	<!-- expressions with item references -->
		<xsl:param name="exprIndex" select="1"/>	<!-- start at first expression -->

		<!-- This template examines all expressions and extracts query item references from the syntax.
			The routine calls itself recursively to iterate through the expressions, passing the current list each time.
		   -->
		<xsl:choose>
			<xsl:when test="$exprIndex &lt;= count($expressions)">
				<!-- Process current expression -->
				<xsl:variable name="myExprItemRefs">
					<!-- Extract query item references from current expresion -->
					<xsl:call-template name="getExprItemRefs">
						<xsl:with-param name="expression" select="$expressions[$exprIndex]"/>
					</xsl:call-template>
				</xsl:variable>
				<!-- Process remaining expressions, including item references from current expression -->
				<xsl:call-template name="extractExprItemRefs">
					<xsl:with-param name="exprItemRefs" select="concat($exprItemRefs, $myExprItemRefs)"/>
					<xsl:with-param name="expressions" select="$expressions"/>
					<xsl:with-param name="exprIndex" select="$exprIndex +1"/>	<!-- search next expression -->
				</xsl:call-template>
			</xsl:when>
			<xsl:otherwise>
				<!-- We've processed all expressions: Return current list -->
				<xsl:value-of select="$exprItemRefs"/>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>
	<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
	<xsl:template name="getExprItemRefs">
		<xsl:param name="myItemRefs"/>	<!-- list of item references extracted from this expression -->
		<xsl:param name="expression"/>	<!-- current expression text -->

		<!-- This is a recursive routine that extracts names of query items referenced in current report expressions. -->
		<xsl:choose>
			<xsl:when test="contains($expression,'[')">
				<!-- Extract first query item reference from current expresion text. -->
				<xsl:variable name="qiName" select="substring-after(substring-before($expression, ']'), '[')"/>
				<!-- Process remaining expression text, appending above item reference to current list -->
				<xsl:call-template name="getExprItemRefs">
					<xsl:with-param name="myItemRefs" select="concat($myItemRefs,'[',$qiName,']; ')"/>
					<xsl:with-param name="expression" select="substring-after($expression,']')"/>	<!-- all expression text after current item reference -->
				</xsl:call-template>
			</xsl:when>
			<xsl:otherwise>
				<!-- We've found all item references in current expression: Return current list -->
				<xsl:value-of select="$myItemRefs"/>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>
	
	<!-- === === === === === === === === === === === === === === === -->
	<xsl:template name="countQueryItems">
		<xsl:param name="myQueryItems"/>	<!-- items in current BI Query -->
		<xsl:param name="queryItemRefs"/>	<!-- dangling data items -->
		<xsl:param name="exprItemRefs"/>	<!-- dangling data items in expressions -->
		<xsl:param name="queryItemCount" select="0"/>	<!-- current item count: initialized at zero -->
		<xsl:param name="queryItemIndex" select="1"/>	<!-- current item count: initialized at zero -->

		<!-- This template counts all of the items in the query that match an explicit query item reference or a
			reference from a report expression. 
			The routine calls itself recursively to iterate through the items.
		   -->
		<xsl:choose>
			<xsl:when test="$queryItemIndex &lt;= count($myQueryItems)">
				<!-- Still processing items in list; Process current item. -->
				<xsl:variable name="myItem" select="$myQueryItems[$queryItemIndex]"/>
				<xsl:variable name="myItemName">
					<xsl:choose>
						<xsl:when test="$myItem/@name"><xsl:value-of select="$myItem/@name"/></xsl:when>
						<xsl:when test="$myItem/@alias"><xsl:value-of select="$myItem/@alias"/></xsl:when>
						<xsl:when test="$myItem/@refItem"><xsl:value-of select="$myItem/@refItem"/></xsl:when>
						<xsl:otherwise></xsl:otherwise>
					</xsl:choose>
				</xsl:variable>
				<xsl:variable name="myCount">
					<xsl:choose>
						<xsl:when test="$myItemName = $queryItemRefs">1</xsl:when>
						<xsl:when test="contains($exprItemRefs, concat('[',$myItemName,']; '))">1</xsl:when>
						<xsl:otherwise>0</xsl:otherwise>
					</xsl:choose>
				</xsl:variable>
				<!--DBG- -><xsl:comment>    queryItem[<xsl:value-of select="$queryItemIndex"/>] = '<xsl:value-of select="$myItemName"/>' (<xsl:value-of select="$myCount"/>)</xsl:comment-->
				<!-- Process next item in list -->
				<xsl:call-template name="countQueryItems">
					<xsl:with-param name="myQueryItems" select="$myQueryItems"/>
					<xsl:with-param name="queryItemRefs" select="$queryItemRefs"/>
					<xsl:with-param name="exprItemRefs" select="$exprItemRefs"/>
					<xsl:with-param name="queryItemCount" select="$queryItemCount + $myCount"/>
					<xsl:with-param name="queryItemIndex" select="$queryItemIndex +1"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:otherwise>
				<!-- All query items have been processed; Return current count -->
				<xsl:value-of select="$queryItemCount"/>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>

	<!-- =============================================================================== -->
</xsl:stylesheet>