Comment compter le nombre de la même année précédente frères et sœurs dans xsl

Je suis en utilisant xslt version 2, je suis en train de transformer un fichier xml en fo sortie, et je suis bloqué sur une problématique spécifique.

Voici à quoi ressemble mon entrée:

    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>
    <a2/>
    <b/>
    <c/>
    <a1/>
    <a1/>
    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>

Ces données, fonctionnellement parlant, contient une liste des "ensembles" définies par a1|a2,b?,c?,d?.

Mon problème est que je ne vois pas comment je peux compter le nombre de a1 balises pour un "set".

En effet, j'ai écrit mon xsl et je reçois une sortie comme ça:

<fo:table>
    <fo:row>
        <fo:cell>b: </fo:cell>
        <fo:cell>b value</fo:cell>
    </fo:row>
    <fo:row>
        <fo:cell>a1: </fo:cell>
        <fo:cell>number of a1 ???</fo:cell> <-- what I am trying to retrieve
    </fo:row>
    <fo:row>
        ...
    </fo:row>
    ...
</fo:table>

J'ai fait une demande-modèle a1+|a2 balises, et je ne fais rien si a1 balise a un frère qui est égale à a1.
Je pense qu'il doit y avoir un moyen de compter le tags avec le précédent frère (mais alors, comment s'assurer de ne compter que les correspondants?)

Tous les conseils seront appréciés!

Edit:
Sur l'exemple ci-dessus de l'entrée, le premier comte doit être de 2:

    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>

alors il devrait être de 4, et non pas à 6:

    <a1/>
    <a1/>
    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>

OriginalL'auteur skoll | 2013-07-13

xslt xslt-2.0

9

Votre question n'est pas vraiment clair.

Ce qui devrait "celui correspondant"?
En comptant tous les a1 avant que le courant serait:
```
 count(preceding-sibling::a1) 
```
si besoin, vous pouvez ajouter des prédicats comme:
```
 count(preceding-sibling::a1[/corresponding one/]) 
```
Compter que le président de la fratrie a1 qui sont dans une séquence de nœuds a1, essayez ceci:
Trouver le premier nœud qui n'est pas une a1.
```
<xsl:variable name="firstnota1" select="preceding-sibling::*[not (self::a1)][1]" />
```
Les rites résultat que, est de compter tous les nœuds avant que le courant a1, moins le nombre de nœuds, avant le premier pas a1 + ce nœud lui-même.
```
<xsl:value-of select="count(preceding-sibling::*) 
       -  count($firstnota1/preceding-sibling::* | $firstnota1)"/>
```
Ou sans variable:
```
<xsl:value-of 
      select="count(preceding-sibling::*)
             -  count( preceding-sibling::*[not (self::a1)][1]
                      /preceding-sibling::*
                      | preceding-sibling::*[not (self::a1)][1] )"/>
```
le problème est que j'ai a1-a1-b-c-d-a1-a1-a1-b-c-d... premier temps, il est de 2, deuxième temps 3. Je vais modifier mon post
Ok, je vois, veuillez jeter un oeil à la mise à jour.
C'est presque ok, mais il renvoie 3 au lieu de 4 pour le 1er set...
Sûr qu'il ne prend en compte que le précédent,-les frères et sœurs. Si vous voulez avoir le comte y compris auto ajouter +1: "select="count(..) - comte(..) +1"
Ok ça y est, mon erreur était que je ne comprends pas l' | $firstnota1, donc je l'ai ignoré. Au lieu de cela, j'ai dû le supprimer puis ajouter 1. Donc, il gère les deux cas : avec ou sans enfant précédent.

OriginalL'auteur hr_117
2

Je voudrais utiliser for-each-group group-adjacent="boolean(self::a1)"> par exemple
```
<xsl:stylesheet
  version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  exclude-result-prefixes="xs">

<xsl:output method="xml" indent="yes"/>

<xsl:template match="root">
  <xsl:for-each-group select="*" group-adjacent="boolean(self::a1)">
    <xsl:choose>
      <xsl:when test="current-grouping-key()">
        <xsl:value-of select="'Count is: ', count(current-group())"/>
      </xsl:when>
      <xsl:otherwise>
        
      </xsl:otherwise>
    </xsl:choose>
  </xsl:for-each-group>
</xsl:template>

</xsl:stylesheet>
```
Si l'entrée est
```
<root>
    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>
    <a2/>
    <b/>
    <c/>
    <a1/>
    <a1/>
    <a1/>
    <a1/>
    <b/>
    <c/>
    <d/>
</root>
```
puis Saxon 9 sorties Count is: 2Count is: 4 de sorte qu'il donne le nombre que vous voulez (mal formaté, il est vrai). Si vous n'obtenez pas de sortie, puis peut-être les éléments que vous avez posté, ont un autre élément parent de celui que j'ai choisi (c'est à dire root). Ou vous utilisez les espaces de noms et les self::a1 doit être adapté.

Je n'ai vraiment pas comment le faire fonctionner avec qui, il me semble que je n'ai jamais "actuel-regroupement-clés()"
Je vais modifier la réponse à vous montrer un échantillon.
Ok +1 mon erreur j'ai essayé d'utiliser le foreach-groupe dans l'élément, de ne pas parent. Mais je suis de l'affichage 421 - 421 - 421 au lieu de 4 - 2 - 1... Il semble que le test test="current-regroupement-clés()" est toujours valable ?
Pas juste l'oublier. C'est une différence de conception: - je construire un fo de la table à partir de a1, à l'aide de for-each-group je doit le construire de des parents. merci pour les explications.
Eh bien... peut-être ne pas l'oublier 🙂 pensez-vous qu'il existe un moyen de récupérer des valeurs de groupes de (a1+,b?,c?,d?) En utilisant pour chaque groupe semble être vraiment plus propre que ma solution

OriginalL'auteur Martin Honnen
1

Essayer de xpath suivante
```
count(preceding-sibling::a1)-count(preceding-sibling::b[1]/preceding-sibling::a1)
```
Cela signifie: nombre de précédents a1 à tous les moins compter de a1 précédent précédent b

Merci pour la réponse, je vais essayer quand j'ai l'opportunité de le faire.
b, c et d sont optionnels (xsd dit de faire), je vais essayer de trouver si c'est vraiment optionnel, ou si mes données sont toujours contenir un particulier (si non, est-il un moyen de trouver le max de dénombrement(précédent-sibling::b[1]/précédent-sibling::a1) / même avec c / même avec d ?)
Vous pouvez stocker le nom de l'élément actuel dans la variable <xsl:variable name="nodeName" select="name()" /> et de l'utiliser ensuite dans le deuxième compte de <xsl:value-of select="count(preceding-sibling::a1)-count(preceding-sibling::node()[name()=$nodeName][1]/preceding-sibling::a1)" />

OriginalL'auteur Jirka Š.

Vous devez vous connecter pour publier un commentaire.