Discussion :

[polymorphisme]

Bonjour,

J'ai un ensemble de noeuds :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
<x:row type='1'/>        1 élément @type='1'
<x:row type='2'/>        pour x éléments @type='2'
<x:row type='empty'/>        et 1 élément @type='empty'
 
etc. cela se répète y fois.

Je cherche à placer un maximum d'ensemble de noeuds du type 1, 2 et empty dans un tableau de n lignes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
<x:table nombreDeLignes="n">
<x:row type='1'/>        1 élément @type='1'
<x:row type='2'/>        pour x éléments @type='2'
<x:row type='empty'/>        et 1 élément @type='empty'
</x:table>

En vous remerciant de votre aide

[thelvin]

Un maximum ? C'est-à-dire, chaque répétition de l'ensemble montré doit se retrouver encadré de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<x:table nombreDeLignes="n">...</x:table>

?
Autrement dit, il y aurait y éléments <x:table> ?

Si c'est le cas, c'est un de ces cas chiants.
Une manière de le voir est de faire un Muench, dont le match porte sur <x:row> et le use porte sur un generate-id() du <x:row type="1"> qui commence la séquence.
Pas évident mais ça se fait.

Attention toutefois, j'ai déjà essayé de faire ce genre de trucs avec le moteur XSLT de base de Java, et il y a une anomalie quand on se sert de generate-id() dans le use, du coup ça ne marche pas.
Avec Saxon ça passe très bien.

[Erwy]

tu pourrais donner un exemple plus parlant parce que je ne comprends pas du tout le problème

[polymorphisme]

Voici un exemple plus concret :

Mon ensemble de noeuds :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
<!-- Premier sous-ensemble composé de 4 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>    
 
<!-- Deuxième sous-ensemble composé de 3 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='empty'/>  
 
<!-- Troisième sous-ensemble composé de 6 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>  
 
<!-- Quatrième sous-ensemble composé de 5 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='empty'/>

Et voici le résultat que je doit obtenir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
<!-- Dans ce premier tableau, je peux insérer les deux premiers sous-ensembles de noeuds, mais pas le troisième sous-ensemble. 
En effet, le premier sous-ensemble comprend 4 éléments et on a 4 <= 7, 
pour le deuxième ensemble de noeuds, on a 4 + 3 <= 7,
mais pour le troisième sous-ensemble, on a 4 + 3 + 6 > 7. -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>        
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='empty'/>  
</x:table>
 
<!-- Dans ce deuxième tableau, je ne peux insérer que 
le troisième sous-ensemble de noeuds puisque 6 <= 7 
et que le quatrième sous-ensemble est trop grand 
puisque on a 6 + 5 > 7 -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>  
</x:table>
 
<!-- Finalement, j'insère le quatrième sous-ensemble de noeuds dans un dernier tableau puisqu'il ne pouvait être contenu dans le tableau précédant -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='empty'/>  
</x:table>

J'ai bien entendu penser à Muench, mais sans avoir pu trouver de résultat !

[Erwy]

tes regroupements sont traités de façon séquentielle ou "optimisé" (minimum de table par exemple) ?

Pas du tout du muench là en tout cas, même pas sur que les clés nous servent à quelque chose

[polymorphisme]

Je dois obtenir un minimum de tableau, dit d'une autre façon, je dois mettre un maximum de sous-ensembles par tableau

[Erwy]

L'approche séquentielle est faisable en xslt 1.0, l'approche optimisé me paraît très douteuse.

[Erwy]

Bon après quelques tests ça me semble faisable et on a bien besoin des clés (en tout cas tel que je l'écris).

Commence à me faire vieux

Va me falloir un peu de temps pour écrire l'exemple par contre.

[Erwy]

Bon après une petite pause déjeuner pour alimenter mon cerveau fatigué j'ai une solution à proposer

Il y a sans doute mieux et il faudrait mieux la tester sur plus de cas mais je n'ai pas trop le temps (détail, j'ai remplacé tes x:row par row, plus simple pour travailler)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
	<xsl:key name="group" match="row[@type!=1]" use="generate-id(preceding-sibling::*[@type=1][position()=1])"/>
	<xsl:variable name="ligne" select="7"/>
	<xsl:variable name="taille_min_group" select="3"/>
	<xsl:template match="test">
		<test>
			<xsl:call-template name="ajout">
				<xsl:with-param name="liste" select="/*/row[@type=1]"/>
				<xsl:with-param name="taille" select="$ligne"/>
			</xsl:call-template>
		</test>
	</xsl:template>
	<xsl:template name="ajout">
		<xsl:param name="liste"/>
		<xsl:param name="taille"/>
		<xsl:param name="table"/>
		<xsl:param name="taillePrec" select="0"/>
		<xsl:choose>
			<xsl:when test="$liste[1]">
				<xsl:choose>
					<xsl:when test="$liste[(count(key('group',generate-id(.)))+1)=$taille]">
						<xsl:variable name="noeud">
							<xsl:copy-of select="$table"/>
							<xsl:for-each select="($liste[(count(key('group',generate-id(.)))+1)=$taille])[1]">
								<xsl:copy-of select=".|key('group',generate-id(.))"/>
							</xsl:for-each>
						</xsl:variable>
						<xsl:choose>
							<xsl:when test="($taille + $taillePrec + $taille_min_group) &lt; ($ligne +1)">
								<xsl:call-template name="ajout">
									<xsl:with-param name="liste" select="$liste[generate-id(.)!=generate-id(($liste[(count(key('group',generate-id(.)))+1)=$taille])[1])]"/>
									<xsl:with-param name="taille" select="$ligne - ($taille + $taillePrec)"/>
									<xsl:with-param name="taillePrec" select="($taille + $taillePrec)"/>
									<xsl:with-param name="table" select="$noeud"/>
								</xsl:call-template>
							</xsl:when>
							<xsl:otherwise>
								<table>
									<xsl:copy-of select="$noeud"/>
								</table>
								<xsl:call-template name="ajout">
							<xsl:with-param name="liste" select="$liste[generate-id(.)!=generate-id(($liste[(count(key('group',generate-id(.)))+1)=$taille])[1])]"/>
							<xsl:with-param name="taille" select="$taille"/>
							<xsl:with-param name="taillePrec" select="0"/>
						</xsl:call-template>
								</xsl:otherwise>	
						</xsl:choose>
 
					</xsl:when>
					<xsl:otherwise>
						<xsl:call-template name="ajout">
							<xsl:with-param name="liste" select="$liste"/>
							<xsl:with-param name="taille" select="$taille - 1"/>
							<xsl:with-param name="taillePrec" select="$taillePrec"/>
							<xsl:with-param name="table" select="$table"/>
						</xsl:call-template>
					</xsl:otherwise>
				</xsl:choose>
			</xsl:when>
			<xsl:otherwise>
				<xsl:if test="$table">
					<table>
						<xsl:copy-of select="$table"/>
					</table>
				</xsl:if>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>
</xsl:stylesheet>

[polymorphisme]

Bonjour Erwy,

tu t'est donné bien de la peine, tu m'aurais expliquer le principe j'aurais déjà été bien content . Merci beaucoup.

Ceci étant, je vais tester cela dès demain à l'aide mon petit jeu de fichiers XML.

[Erwy]

tu t'est donné bien de la peine, tu m'aurais expliquer le principe j'aurais déjà été bien content .

Je n'étais pas sûr de la validité du principe avant de le tester, ce qui l'aurait rendu ardu à expliquer
Puis ce n'est pas souvent qu'il y a un problème rigolo sur ce forum, bien le droit de m'amuser un peu

[Loceka]

J'ai pas vraiment regardé la solution (mon parseur mental de XSL est un peu mort ce matin) mais je ne pensais même pas qu'il puisse y avoir une solution en XSL. Bravo Erwy !

[Erwy]

Merci.

Un détail que j'ai oublié, je n'ai pas fait de tri au départ sur les groupes qui sont plus grand que la table, si ce n'est pas fait mon algo plante .

A faire donc dans le premier appel au template nommé

[polymorphisme]

Bonjour,

j'avais noté en effet cela car c'est un cas que je rencontre.

[Erwy]

c'est un cas que je rencontre.

Tu le traite comment : en l'ignorant ou le casant quand même dans une table avec des lignes supplémentaires ?