<?xml version="1.0" encoding="UTF-8" ?>

<!--

 (C) Copyright Nokia Corporation and/or its subsidiary(-ies) 2009 - 2010. All rights reserved.

-->

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

                xmlns:dita2html="http://dita-ot.sourceforge.net/ns/200801/dita2html"

                version="1.0"

                exclude-result-prefixes="dita2html">

  <xsl:include href="utilities.xsl"/>

  <xsl:strip-space elements="cxxFunctionParameterDeclaredType"/>

  <!-- Styling -->

  <!-- ===================================================================== -->

  <xsl:template match="*[contains(@class, ' topic/topic ')]" mode="gen-user-styles">

    <link rel="stylesheet" type="text/css" href="{$PATH2PROJ}{$CSSPATH}nokiacxxref.css"/>

  </xsl:template>

  <xsl:template match="*[contains(@class, ' apiRef/apiRef ')]" mode="gen-user-head">

    <meta name="keywords" content="api"/>

  </xsl:template>

  <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

                          contains(@class, ' cxxStruct/cxxStruct ') or

                          contains(@class, ' cxxUnion/cxxUnion ')]//

                          *[contains(@class, ' topic/link ')][@role='parent']" priority="2000"/>

  <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

                          contains(@class, ' cxxStruct/cxxStruct ') or

                          contains(@class, ' cxxUnion/cxxUnion ')]//

                          *[contains(@class, ' topic/link ')]

                           [@role='child' or @role='descendant']" priority="2000"/>

  <!-- Common API reference overrides -->

  <!-- ===================================================================== -->

  <!-- Remove title from apiDesc -->

  <xsl:template match="*[contains(@class,' apiRef/apiDesc ')]" mode="section-fmt">

    <xsl:if test="node()">

      <div>

        <xsl:call-template name="start-revflag"/>

        <!--

        <xsl:apply-templates select="." mode="sectionTitle">

          <xsl:with-param name="titleType" select="$titleType"/>

        </xsl:apply-templates>

        -->

        <xsl:apply-templates select="node()[not(contains(@class,' topic/title '))]"/>

        <xsl:call-template name="end-revflag"/>

      </div>

    </xsl:if>

  </xsl:template>

  <!-- Override to support "cxxapiref.title-fmt" mode. -->

  <xsl:template match="*[contains(@class, ' apiRef/apiRef ')]/*[contains(@class, ' topic/title ')]">

    <xsl:param name="headinglevel">

      <xsl:choose>

        <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')]) > 6">6</xsl:when>

        <xsl:otherwise><xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])"/></xsl:otherwise>

      </xsl:choose>

    </xsl:param>

    <xsl:element name="h{$headinglevel}">

      <xsl:attribute name="class">topictitle<xsl:value-of select="$headinglevel"/></xsl:attribute>

      <xsl:call-template name="commonattributes">

        <xsl:with-param name="default-output-class">topictitle<xsl:value-of select="$headinglevel"/></xsl:with-param>

      </xsl:call-template>

      <xsl:apply-templates select="." mode="cxxapiref.title-fmt"/>

    </xsl:element>

  </xsl:template>

  <!-- API Reference topic title content -->

  <xsl:template match="*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt" priority="0">

    <xsl:apply-templates/>

  </xsl:template>

  <!-- Disable API reference body processing that adds a horizontal rule --> 

  <xsl:template match="*[contains(@class,' apiRef/apiDetail ')]" priority="0">

    <xsl:call-template name="topic.body"/>

  </xsl:template>

  <!-- File -->

  <!-- ===================================================================== -->

  <!-- File title content -->

  <xsl:template match="*[contains(@class, ' cxxFile/cxxFile ')]/*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

    <xsl:apply-templates/>

    <xsl:text> </xsl:text>

    <xsl:call-template name="getString">

      <xsl:with-param name="stringName" select="'File Reference'"/>

    </xsl:call-template>

  </xsl:template>

  <xsl:template match="*[contains(@class, ' cxxFile/cxxFileAPIItemLocation ')]"/>

  <!-- Struct -->

  <!-- ===================================================================== -->

  <!-- Struct title content -->

  <xsl:template match="*[contains(@class, ' cxxStruct/cxxStruct ')]/*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

    <xsl:apply-templates/>

    <xsl:call-template name="cxxapiref.title-fmt.suffix">

      <xsl:with-param name="type" select="'Struct'"/>

    </xsl:call-template>

  </xsl:template>

  <!-- Union -->

  <!-- ===================================================================== -->

  <!-- Class or union title content -->

  <xsl:template match="*[contains(@class, ' cxxUnion/cxxUnion ')]/

                         *[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

    <xsl:apply-templates/>

    <xsl:call-template name="cxxapiref.title-fmt.suffix">

      <xsl:with-param name="type" select="'Union'"/>

    </xsl:call-template>

  </xsl:template>

  <!-- Class -->

  <!-- ===================================================================== -->

  <!-- Override API reference with base processing -->

  <xsl:template match="/*[contains(@class,' cxxClass/cxxClass ') or

                          contains(@class, ' cxxStruct/cxxStruct ') or

                          contains(@class, ' cxxFile/cxxFile ') or

                          contains(@class, ' cxxUnion/cxxUnion ')]">

    <xsl:call-template name="chapter-setup"/>

  </xsl:template>

  <!-- Class or union title content -->

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ')]/

                         *[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

    <xsl:apply-templates/>

    <xsl:call-template name="cxxapiref.title-fmt.suffix">

      <xsl:with-param name="type" select="'Class'"/>

    </xsl:call-template>

  </xsl:template>

  <xsl:template name="cxxapiref.title-fmt.suffix">

    <xsl:param name="type"/>

    <xsl:variable name="templates"

                  select="../*[contains(@class, ' cxxClass/cxxClassDetail ') or

                               contains(@class, ' cxxStruct/cxxStructDetail ') or

                               contains(@class, ' cxxUnion/cxxUnionDetail ')]/

                               *[contains(@class, ' cxxClass/cxxClassDefinition ') or

                                 contains(@class, ' cxxStruct/cxxStructDefinition ') or

                                 contains(@class, ' cxxUnion/cxxUnionDefinition ')]/

                                 *[contains(@class, ' cxxClass/cxxClassTemplateParamList ') or

                                   contains(@class, ' cxxStruct/cxxStructTemplateParamList ') or

                                   contains(@class, ' cxxUnion/cxxUnionTemplateParamList ')]"/>

    <xsl:for-each select="$templates">

      <xsl:text>&lt; </xsl:text>

        <xsl:for-each select="*[contains(@class, ' cxxClass/cxxClassTemplateParameter ') or

                                contains(@class, ' cxxStruct/cxxStructTemplateParameter ') or

                                contains(@class, ' cxxUnion/cxxUnionTemplateParameter ')]">

          <xsl:if test="not(position() = 1)">, </xsl:if>

          <xsl:value-of select="*[contains(@class, ' cxxClass/cxxClassTemplateParamDeclarationName ') or

                                  contains(@class, ' cxxStruct/cxxStructTemplateParamDeclarationName ') or

                                  contains(@class, ' cxxUnion/cxxUnionTemplateParamDeclarationName ')]"/>

        </xsl:for-each>

        <xsl:text> &gt;</xsl:text>

    </xsl:for-each>

    <xsl:text> </xsl:text>

    <xsl:choose>

      <xsl:when test="contains(., '&lt;') or $templates">

        <xsl:call-template name="getString">

          <xsl:with-param name="stringName" select="concat($type, ' Template Reference')"/>

        </xsl:call-template>

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="getString">

          <xsl:with-param name="stringName" select="concat($type, ' Reference')"/>

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Class and struct derivation section -->

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

                         contains(@class, ' cxxStruct/cxxStructDerivations ')]">

    <xsl:call-template name="topic.section"/>

  </xsl:template>

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

                         contains(@class, ' cxxStruct/cxxStructDerivations ')]" mode="get-output-class">

    <xsl:text>section derivation</xsl:text>

  </xsl:template>

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

                         contains(@class, ' cxxStruct/cxxStructDerivations ')]" mode="section-fmt">

    <xsl:variable name="flagrules">

      <xsl:call-template name="getrules"/>

    </xsl:variable>

    <xsl:call-template name="start-revflag">

      <xsl:with-param name="flagrules" select="$flagrules"/>

    </xsl:call-template>

    <xsl:call-template name="sect-heading">

      <xsl:with-param name="defaulttitle">

        <xsl:call-template name="getString">

          <xsl:with-param name="stringName" select="'cxxBaseClass'"/>

        </xsl:call-template>

      </xsl:with-param>

    </xsl:call-template>

    <ul class="derivation derivation-root">

      <xsl:apply-templates select="ancestor::*[contains(@class, ' cxxClass/cxxClass ') or

                                               contains(@class, ' cxxStruct/cxxStruct ')][1]" mode="derivation"/>

    </ul>

    <!--

    <xsl:call-template name="sect-heading">

      <xsl:with-param name="defaulttitle">Reverse inheritance path</xsl:with-param>

    </xsl:call-template>

    <xsl:apply-templates select="ancestor::*[contains(@class, ' cxxClass/cxxClass ') or

                                             contains(@class, ' cxxStruct/cxxStruct ')][1]" mode="derivation.reverse"/>

    -->

    <xsl:call-template name="end-revflag">

      <xsl:with-param name="flagrules" select="$flagrules"/>

    </xsl:call-template>

  </xsl:template>

  <!-- Class and struct derivation walker -->

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

                         contains(@class, ' cxxStruct/cxxStruct ')]"

                mode="derivation">

    <xsl:param name="link" select="/.."/>

    <xsl:param name="depth" select="0"/>

    <xsl:param name="class"/>

    <li class="derivation-depth-{$depth} {$class}">

      <xsl:choose>

        <xsl:when test="$link">

          <xsl:apply-templates select="$link"/>

        </xsl:when>

        <xsl:otherwise>

          <xsl:value-of select="*[contains(@class, ' topic/title ')]"/>

        </xsl:otherwise>

      </xsl:choose>

      <xsl:variable name="derivation"

                    select="*[contains(@class, ' topic/body ')]/

                              *[contains(@class, ' apiRef/apiDef ')]/

                                *[contains(@class, ' cxxClass/cxxClassDerivations ') or

                                  contains(@class, ' cxxStruct/cxxStructDerivations ')]/

                                  *[contains(@class, ' cxxClass/cxxClassDerivation ') or

                                    contains(@class, ' cxxStruct/cxxStructDerivation ')]"/>

      <xsl:if test="$derivation">

        <ul class="derivation">

         <xsl:for-each select="$derivation">

          <xsl:variable name="cls">

            <xsl:if test="not(position() = last())">derivation-has-next</xsl:if>

          </xsl:variable>

          <xsl:variable name="base" select="*[contains(@class, ' cxxClass/cxxClassBaseClass ') or

                                              contains(@class, ' cxxClass/cxxClassBaseStruct ') or

                                              contains(@class, ' cxxClass/cxxClassBaseUnion ') or

                                              contains(@class, ' cxxStruct/cxxStructBaseClass ') or

                                              contains(@class, ' cxxStruct/cxxStructBaseStruct ') or

                                              contains(@class, ' cxxStruct/cxxStructBaseUnion ')]"/>

          <xsl:variable name="url"> 

            <xsl:call-template name="strip-url-fragment">

              <xsl:with-param name="url" select="$base/@href"/>

            </xsl:call-template>

          </xsl:variable>

          <xsl:if test="normalize-space($url)"><!-- infinite loop guard -->

            <xsl:variable name="doc" select="document($url, .)"/>

            <xsl:apply-templates select="$doc/*[contains(@class, ' cxxClass/cxxClass ') or

                                                contains(@class, ' cxxStruct/cxxStruct ')]"

                                 mode="derivation">

               <xsl:with-param name="link" select="$base"/>

               <xsl:with-param name="depth" select="$depth + 1"/>

               <xsl:with-param name="class" select="$cls"/>

             </xsl:apply-templates>

           </xsl:if>

         </xsl:for-each>

        </ul>

      </xsl:if>

    </li>

  </xsl:template>

  <!-- Class and struct derivation walker. The walker inverts the tree. -->

  <!--

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

                         contains(@class, ' cxxStruct/cxxStruct ')]"

                mode="derivation.reverse">

    <xsl:param name="link" select="/.."/>

    <xsl:param name="contents"/>

    <xsl:variable name="title">

      <xsl:choose>

        <xsl:when test="$link">

          <xsl:apply-templates select="$link"/>

        </xsl:when>

        <xsl:otherwise>

          <xsl:value-of select="*[contains(@class, ' topic/title ')]"/>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:variable name="derivation"

                  select="*[contains(@class, ' topic/body ')]/

                            *[contains(@class, ' apiRef/apiDef ')]/

                              *[contains(@class, ' cxxClass/cxxClassDerivations ') or

                                contains(@class, ' cxxStruct/cxxStructDerivations ')]/

                                *[contains(@class, ' cxxClass/cxxClassDerivation ') or

                                  contains(@class, ' cxxStruct/cxxStructDerivation ')]"/>

    <xsl:choose>

      <xsl:when test="$derivation">

       <xsl:for-each select="$derivation">

         <xsl:variable name="base" select="*[contains(@class, ' cxxClass/cxxClassBaseClass ') or

                                             contains(@class, ' cxxClass/cxxClassBaseStruct ') or

                                             contains(@class, ' cxxClass/cxxClassBaseUnion ') or

                                             contains(@class, ' cxxStruct/cxxStructBaseClass ') or

                                             contains(@class, ' cxxStruct/cxxStructBaseStruct ') or

                                             contains(@class, ' cxxStruct/cxxStructBaseUnion ')]"/>

         <xsl:variable name="url"> 

           <xsl:call-template name="strip-url-fragment">

             <xsl:with-param name="url" select="$base/@href"/>

           </xsl:call-template>

         </xsl:variable>

         <xsl:if test="normalize-space($url)">

           <xsl:variable name="doc" select="document($url, .)"/>

           <xsl:apply-templates select="$doc/*[contains(@class, ' cxxClass/cxxClass ') or

                                               contains(@class, ' cxxStruct/cxxStruct ')]"

                                mode="derivation.reverse">

             <xsl:with-param name="contents">

               <li>

                 <xsl:copy-of select="$title"/>

                 <xsl:if test="normalize-space($contents)">

                   <ul>

                     <xsl:copy-of select="$contents"/>

                   </ul>  

                 </xsl:if>

               </li>

             </xsl:with-param>

             <xsl:with-param name="link" select="$base"/>

           </xsl:apply-templates>

         </xsl:if>

       </xsl:for-each>

      </xsl:when>

      <xsl:otherwise>

        <ul class="derivation-root">

          <li>

            <xsl:copy-of select="$title"/>

            <ul>

              <xsl:copy-of select="$contents"/>

            </ul>

          </li>

        </ul>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  -->

  <!-- Class, struct, or union body -->

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDetail ') or

                         contains(@class, ' cxxStruct/cxxStructDetail ') or

                         contains(@class, ' cxxUnion/cxxUnionDetail ')]">

    <xsl:apply-templates select="*[contains(@class, ' cxxClass/cxxClassDefinition ') or

                                   contains(@class, ' cxxStruct/cxxStructDefinition ') or

                                   contains(@class, ' cxxUnion/cxxUnionDefinition ')]" mode="signature"/>

    <xsl:apply-templates select="*[(contains(@class, ' topic/section ') or

                                    contains(@class, ' topic/example ')) and

                                   not(contains(@class, ' apiRef/apiDef '))]"/>

    <xsl:apply-templates select="*[contains(@class, ' cxxClass/cxxClassDefinition ') or

                                   contains(@class, ' cxxStruct/cxxStructDefinition ')]/

                                   *[contains(@class, ' cxxClass/cxxClassDerivations ') or

                                     contains(@class, ' cxxStruct/cxxStructDerivations ')]"/>

    <xsl:apply-templates select="../*[contains(@class, ' cxxClass/cxxClassNested ') or

                                      contains(@class, ' cxxStruct/cxxStructNested ') or

                                      contains(@class, ' cxxUnion/cxxUnionNested ')]/

                                      *[contains(@class, ' cxxClass/cxxClassNestedDetail ') or

                                        contains(@class, ' cxxStruct/cxxStructNestedDetail ') or

                                        contains(@class, ' cxxUnion/cxxUnionNestedDetail ')]"/>

    <div class="section member-index">

      <xsl:for-each select="..">

        <xsl:variable name="inherited" select="*[contains(@class, ' cxxClass/cxxClassInherits ') or

                                                 contains(@class, ' cxxStruct/cxxStructInherits ')]/

                                                 *[contains(@class, ' cxxClass/cxxClassInheritsDetail ') or

                                                   contains(@class, ' cxxStruct/cxxStructInheritsDetail ')]"/>

<!--

        <xsl:call-template name="member-index-block">

          <xsl:with-param name="title" select="'Member Nested Classes'"/>

          <xsl:with-param name="nodes" select="*[contains(@class, ' cxxClass/cxxClassNested ')]"/>

        </xsl:call-template>

-->      

        <xsl:call-template name="member-index-group">

          <xsl:with-param name="title" select="'Member Functions'"/>

          <xsl:with-param name="nodes" select="*[contains(@class, ' cxxFunction/cxxFunction ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-block">

          <xsl:with-param name="title" select="'Inherited Functions'"/>

          <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassFunctionInherited ') or

                                                            contains(@class, ' cxxStruct/cxxStructFunctionInherited ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-group">

          <xsl:with-param name="title" select="'Member Enumerations'"/>

          <xsl:with-param name="nodes" select="*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-block">

          <xsl:with-param name="title" select="'Inherited Enumerations'"/>

          <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassEnumerationInherited ') or

                                                            contains(@class, ' cxxStruct/cxxStructEnumerationInherited ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-group">

          <xsl:with-param name="title" select="'Member Type Definitions'"/>

          <xsl:with-param name="nodes" select="*[contains(@class, ' cxxTypedef/cxxTypedef ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-group">

          <xsl:with-param name="title" select="'Attributes'"/>

          <xsl:with-param name="nodes" select="*[contains(@class, ' cxxVariable/cxxVariable ')]"/>

        </xsl:call-template>

        <xsl:call-template name="member-index-block">

          <xsl:with-param name="title" select="'Inherited Attributes'"/>

          <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassVariableInherited ') or

                                                            contains(@class, ' cxxStruct/cxxStructVariableInherited ')]"/>

        </xsl:call-template>

      </xsl:for-each>

    </div>

    <xsl:for-each select="..">

      <xsl:for-each select="*[contains(@class, ' topic/related-links ')]">

        <xsl:call-template name="topic.related-links"/>

      </xsl:for-each>

    </xsl:for-each>

    <!-- Pull nested topics into groups, normal fall-through is disabled -->

    <xsl:variable name="all-functions" select="../*[contains(@class, ' cxxFunction/cxxFunction ')]"/>

    <xsl:variable name="constructor" select="$all-functions[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/*[contains(@class, ' apiRef/apiQualifier ')][@name = 'constructor']]"/>      	

    <xsl:variable name="destructor" select="$all-functions[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/*[contains(@class, ' apiRef/apiQualifier ')][@name = 'destructor']]"/>

    <xsl:if test="$constructor | $destructor">

      <h1 class="pageHeading topictitle1">Constructor &amp; Destructor Documentation</h1>

      <xsl:apply-templates select="$constructor" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

      <xsl:apply-templates select="$destructor" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

    </xsl:if>

    <xsl:variable name="functions" select="$all-functions[not(count($constructor | $destructor) = count(. | $constructor | $destructor))]"/>

    <xsl:if test="$functions">

      <h1 class="pageHeading topictitle1">Member Functions Documentation</h1>

      <xsl:apply-templates select="$functions" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

    </xsl:if>

    <xsl:variable name="structures" select="../*[contains(@class, ' cxxStruct/cxxStruct ')]"/>

    <xsl:if test="$structures">

      <h1 class="pageHeading topictitle1">Member Structures Documentation</h1>

      <xsl:apply-templates select="$structures" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

    </xsl:if>

    <xsl:variable name="enums" select="../*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]"/>

    <xsl:if test="$enums">

      <h1 class="pageHeading topictitle1">Member Enumerations Documentation</h1>

      <xsl:apply-templates select="$enums" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

    </xsl:if>

    <xsl:variable name="typedefs" select="../*[contains(@class, ' cxxTypedef/cxxTypedef ')]"/>

    <xsl:if test="$typedefs">

     <h1 class="pageHeading topictitle1">Member Type Definitions Documentation</h1>

     <xsl:apply-templates select="$typedefs" mode="child.topic">

       <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

     </xsl:apply-templates>

    </xsl:if>

    <xsl:variable name="variables" select="../*[contains(@class, ' cxxVariable/cxxVariable ')]"/>

    <xsl:if test="$variables">

      <h1 class="pageHeading topictitle1">Member Data Documentation</h1>

      <xsl:apply-templates select="$variables" mode="child.topic">

        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

      </xsl:apply-templates>

    </xsl:if>

  </xsl:template>

  <!-- Omit, pulled by class/struct body -->

  <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

                         contains(@class, ' cxxStruct/cxxStruct ') or

                         contains(@class, ' cxxUnion/cxxUnion ')]/

                         *[contains(@class, ' topic/topic ') or

                           contains(@class, ' topic/related-links ')]"/>

  <!-- Class and struct body class -->

  <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

                         contains(@class, ' cxxStruct/cxxStruct ') or

                         contains(@class, ' cxxUnion/cxxUnion ')]/

                         *[contains(@class,' topic/topic ')]/

                           *[contains(@class,' topic/body ')]"

                mode="get-output-class">

    <xsl:text>topicbody</xsl:text>

    <xsl:value-of select="count(ancestor-or-self::*[contains(@class,' topic/topic ')])"/> 

  </xsl:template>  

  <!-- Member index group -->

  <xsl:template name="member-index-group">

    <xsl:param name="title"/>

    <xsl:param name="nodes"/>

    <xsl:call-template name="member-index-block">

      <xsl:with-param name="nodes"

                      select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

                                       *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'public']]"/>

      <xsl:with-param name="title" select="concat('Public ', $title)"/>

    </xsl:call-template>

    <xsl:call-template name="member-index-block">

      <xsl:with-param name="nodes"

                      select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

                                       *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'protected']]"/>

      <xsl:with-param name="title" select="concat('Protected ', $title)"/>

    </xsl:call-template>

    <xsl:call-template name="member-index-block">

      <xsl:with-param name="nodes"

                      select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

                                       *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'private']]"/>

      <xsl:with-param name="title" select="concat('Private ', $title)"/>

    </xsl:call-template>

  </xsl:template>

  <!-- Member index table -->

  <xsl:template name="member-index-block">

    <xsl:param name="nodes" select="/.."/>

    <xsl:param name="title"/>

    <xsl:if test="$nodes">

      <table border="1" class="member-index">

        <thead>

          <tr>

            <th colspan="2">

              <xsl:value-of select="$title"/>

            </th>

          </tr>

        </thead>

        <tbody>

          <xsl:apply-templates select="$nodes" mode="class-members">

            <xsl:sort select="number(boolean(*[contains(@class, ' apiRef/apiDetail ')]/

                                               *[contains(@class, ' apiRef/apiDef ')]/

                                                 *[contains(@class, ' apiRef/apiQualifier ')]