[XSLT] Aplatir un XML (Structure arborescente => Structure linéaire)

Version imprimable

Bonjour,

Je voudrais transformer une structure arborescente en structure linéaire.
Pour faire simple, partant d'un XML ayant une structure du style:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ROOT |--S1 | |--E1 | | |--B1 | | |--B2 | |--E2 | | |--B3 | | |--B4 |--S2 | |--E3 | | |--B5 | | |--B6 | | |--B7 | |--E4 | | |--B8
J'aimerais obtenir un XML "aplati" du style
Code:

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 ROOT |--S1 | |--E1 | |--B1 |--S1 | |--E1 | |--B2 |--S1 | |--E2 | |--B3 |--S1 | |--E2 | |--B4 |--S2 | |--E3 | |--B5 |--S2 | |--E3 | |--B6 |--S2 | |--E3 | |--B7 |--S3 | |--E4 | |--B8
En gros, ne conserver que la racine de premier niveau et "écraser" tout le reste.
Ceci étant rendu plus difficile, sachant que je ne connais pas la structure de mon XML et ne connait pas non plus le nom de mes élèments...

Etant débutant, merci de me dire si cela est rééllement possible et me donner des pistes le cas échéant.

Merci d'avance.

Bonjour,

Citation:

Envoyé par SONY30

En gros, ne conserver que la racine de premier niveau et "écraser" tout le reste.

Ca semble un peu plus compliqué que cela, il y a aussi une "factorisation" avec les éléments fils des éléments de premier niveau.

Si je me base sur l'exemple que tu as donné, ceci devrait faire l'affaire :
Code:

1 2 3 4 5 6 7 8 9 10 <xsl:template match="/*"> <xsl:copy> <xsl:for-each select="*/*/*"> <xsl:element name="{name(../..)}"> <xsl:element name="{name(..)}"/> <xsl:copy-of select="."/> </xsl:element> </xsl:for-each> </xsl:copy> </xsl:template>

16/04/2007, 09h56
SONY30
Le "souci" c'est que je ne connais pas la profondeur de mon XML.

Mon besoin initial était de transformer ce style de XML là en tableau HTML, j'arrive à obtenir un HTML (1-n)
Code:

1 2 3 4 5 S1---E1---B1 -----------B2 -----E2---B3 -----------B4
alors que je souhaiterais obtenir un HTML (n-n)
Code:

1 2 3 4 5 S1---E1---B1 S1---E1---B2 S1---E2---B3 S1---E2---B4
Alors je m'étais dit (à tort ?) qu'il était peut-être plus facile de faire cela en plusieurs étapes, une première transformation qui m'aplati mon XML puis une deuxième qui me le traduit en HTML.
Qu'en pensez-vous ?

Bonjour,

Voici ce que je propose comme feuille de style :

Code:

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
<xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:apply-templates/>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*[count(*)=0]">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
   <xsl:choose>
    <xsl:when test="$p = 0">
     <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:otherwise>
     <xsl:variable name="aname">
      <xsl:for-each select="ancestor::*[position()=$p]">
       <xsl:value-of select="name()"/>
      </xsl:for-each>
     </xsl:variable>
     <xsl:element name="{$aname}">
      <xsl:for-each select="ancestor::*[position()=$p]/@*">
       <xsl:copy/>
      </xsl:for-each>
      <xsl:call-template name="aplati">
       <xsl:with-param name="p" select="$p - 1"/>
      </xsl:call-template>
     </xsl:element>
    </xsl:otherwise>
   </xsl:choose>
  </xsl:template>
 </xsl:stylesheet>

(testé avec tXs : http://www.agencexml.com/txs/fr)

Le principe est de chercher toutes les feuilles de l'arbre et de créer une branche de tous les ancêtres sauf la racine.

Cela fonctionne très bien pour des éléments racine, mais va multiplier les lignes pour les éléments text.
De plus je voudrais répéter les éléments text pour chaque ligne.

Prenons le XML suivant

Code:

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
<S1>
  <lib>Structure 1</lib>
  <E1>
    <SEC1>
      <type>Type 1</type>
      <B1>
        <lib>Budget 1</lib>
      </B1>
      <B2>
        <lib>Budget 2</lib>
      </B2>
    </SEC1>
  </E1>
  <E2>
    <SEC1>
      <type>Type 2</type>
      <B1>
        <lib>Budget 3</lib>
      </B1>
      <B2>
        <lib>Budget 4</lib>
      </B2>
    </SEC1>
  </E2>
</S1>
<S2>
  <lib>Structure 2</lib>
  <E3>
    <SEC1>
      <type>Type 1</type>
      <B5>
        <lib>Budget 5</lib>
      </B5>
      <B6>
        <lib>Budget 6</lib>
      </B6>
      <B7>
        <lib>Budget 7</lib>
      </B7>
    </SEC1>
  </E3>
  <E4>
    <SEC1>
      <type>Type 2</type>
      <B8>
        <lib>Budget 8</lib>
      </B8>
    </SEC1>
  </E4>
</S2>

Je souhaiterais obtenir le XML suivant

Code:

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
<ROOT>
<S1>
  <lib>Structure 1</lib>
  <type>Type 1</type>
  <libb>Budget 1</libb>
</S1>
<S1>
  <lib>Structure 1</lib>
  <type>Type 1</type>
  <libb>Budget 2</libb>
</S1>
<S1>
  <lib>Structure 1</lib>
  <type>Type 2</type>
  <libb>Budget 3</libb>
</S1>
<S1>
  <lib>Structure 1</lib>
  <type>Type 2</type>
  <libb>Budget 4</libb>
</S1>
<S2>
  <lib>Structure 2</lib>
  <type>Type 1</type>
  <libb>Budget 5</libb>
</S2>
<S2>
  <lib>Structure 2</lib>
  <type>Type 1</type>
  <libb>Budget 6</libb>
</S2>
<S2>
  <lib>Structure 2</lib>
  <type>Type 1</type>
  <libb>Budget 7</libb>
</S2>
<S2>
  <lib>Structure 2</lib>
  <type>Type 2</type>
  <libb>Budget 8</libb>
</S2>
</ROOT>

OK, je comprends mieux : il faut "ramasser" les valeurs textes présentes dans les ancêtres.

Code:

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
<xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:apply-templates mode="aplat" select="//*[count(*)=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
   <xsl:if test="$p != 0">
     <xsl:variable name="aname">
      <xsl:for-each select="ancestor::*[position()=$p]">
       <xsl:value-of select="name()"/>
      </xsl:for-each>
     </xsl:variable>
     <xsl:choose>
      <xsl:when test="$p = count(ancestor::*) -1">
       <xsl:element name="{$aname}">
        <xsl:for-each select="ancestor::*[position()=$p]/@*">
         <xsl:copy/>
        </xsl:for-each>
        <xsl:for-each select="ancestor::*[position()=$p]/*[count(*)=0 and text()!='']">
         <xsl:copy-of select="."/>
        </xsl:for-each>
        <xsl:call-template name="aplati">
         <xsl:with-param name="p" select="$p - 1"/>
        </xsl:call-template>
       </xsl:element>
      </xsl:when>
      <xsl:otherwise>
       <xsl:for-each select="ancestor::*[position()=$p]/*[count(*)=0 and text()!='']">
        <xsl:copy-of select="."/>
       </xsl:for-each>
       <xsl:call-template name="aplati">
        <xsl:with-param name="p" select="$p - 1"/>
       </xsl:call-template>
      </xsl:otherwise>
     </xsl:choose>
   </xsl:if>
  </xsl:template>
 </xsl:stylesheet>

(testé avec http://www.agencexml.com/txs/fr)

16/04/2007, 15h01
SONY30

ça fonctionne ! :king:

J'aurais jamais trouvé tout seul !
Je vais essayé de comprendre le code :aie:

Merci beaucoup.

Encore un petit souci, les éléments frères déclenchent la création d'une nouvelle ligne, ce qui ne devrait pas être le cas.

Code:

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
<ROOT>
<S1>
  <lib>Structure 1</lib>
  <E1>
    <Z>
      <SEC1>
        <type>Type 1</type>
        <B1>
          <lib>Budget 1</lib>
          <t>B</t>
        </B1>
        <B2>
          <lib>Budget 2</lib>
          <t>B</t>
        </B2>
      </SEC1>
    </Z>
  </E1>
  <E2>
    <Z>
      <SEC1>
        <type>Type 2</type>
        <B1>
          <lib>Budget 3</lib>
          <t>B</t>
        </B1>
        <B2>
          <lib>Budget 4</lib>
          <t>B</t>
        </B2>
      </SEC1>
    </Z>
  </E2>
</S1>
<S2>
  <lib>Structure 2</lib>
  <E3>
    <Z>
      <SEC1>
        <type>Type 1</type>
        <B5>
          <lib>Budget 5</lib>
          <t>B</t>
        </B5>
        <B6>
          <lib>Budget 6</lib>
          <t>B</t>
        </B6>
        <B7>
          <lib>Budget 7</lib>
          <t>B</t>
        </B7>
      </SEC1>
    </Z>
  </E3>
  <E4>
    <Z>
      <SEC1>
        <type>Type 2</type>
        <B8>
          <lib>Budget 8</lib>
          <t>B</t>
        </B8>
      </SEC1>
    </Z>
  </E4>
</S2>
</ROOT>

donne

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<S1>
<lib>Structure 1</lib>
<type>Type 1</type>
<lib>Budget 1</lib>
<t>B</t>
</S1>
<S1>
<lib>Structure 1</lib>
<type>Type 1</type>
<lib>Budget 1</lib>
<t>B</t>
</S1><S1>
<lib>Structure 1</lib>
<type>Type 1</type>
<lib>Budget 2</lib>
<t>B</t>
</S1>
<S1>
<lib>Structure 1</lib>
<type>Type 1</type>
<lib>Budget 2</lib>
<t>B</t>
</S1>
...

Effectivement, je n'avais pas vu cette possibilité. En fait, c'est tout simple à corriger car l'algo est basé sur la sélection des feuilles les plus profondes : il suffit de ne sélectionner que celles qui sont les premières dans leur branche en rajoutant la condition XPath

Code:

and count(preceding-sibling::*[count(*)=0])=0

Au total :

Code:

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
 <xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:apply-templates mode="aplat" select="//*[count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
   <xsl:if test="$p != 0">
     <xsl:variable name="aname">
      <xsl:for-each select="ancestor::*[position()=$p]">
       <xsl:value-of select="name()"/>
      </xsl:for-each>
     </xsl:variable>
     <xsl:choose>
      <xsl:when test="$p = count(ancestor::*) -1">
       <xsl:element name="{$aname}">
        <xsl:for-each select="ancestor::*[position()=$p]/@*">
         <xsl:copy/>
        </xsl:for-each>
        <xsl:for-each select="ancestor::*[position()=$p]/*[count(*)=0 and text()!='']">
         <xsl:copy-of select="."/>
        </xsl:for-each>
        <xsl:call-template name="aplati">
         <xsl:with-param name="p" select="$p - 1"/>
        </xsl:call-template>
       </xsl:element>
      </xsl:when>
      <xsl:otherwise>
       <xsl:for-each select="ancestor::*[position()=$p]/*[count(*)=0 and text()!='']">
        <xsl:copy-of select="."/>
       </xsl:for-each>
       <xsl:call-template name="aplati">
        <xsl:with-param name="p" select="$p - 1"/>
       </xsl:call-template>
      </xsl:otherwise>
     </xsl:choose>
   </xsl:if>
  </xsl:template>
 </xsl:stylesheet>

(testé avec http://www.agencexml.com/txs/fr/)

Bonjour,

Une variante, peut-être pas plus performante, mais plus courte. ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/*">
    <xsl:copy>
        <xsl:for-each select="descendant::*[*[not(preceding-sibling::*/*|following-sibling::*/*) and not(*)]]/*[1]">
            <xsl:element name="{name(ancestor::*[last() - 1])}">
                <xsl:for-each select="/*/descendant::*[count(descendant::*|current()) = count(descendant::*)]">
                    <xsl:copy-of select="*[text()][1]"/>
                </xsl:for-each>
            </xsl:element>
        </xsl:for-each>
    </xsl:copy>
</xsl:template>
</xsl:stylesheet>

Mais si le but de cet traitement est uniquement de linéariser ta source XML pour en faire un tableau, il est à mon avis possible de s'en passer et de le générer directement. On peut t'y aider, si tu exposes clairement et précisément ton problème.

Ton exemple ne fonctionne pas GrandFather, les éléments racines sont conservés.
Effectivement cela doit pouvoir se faire en 1 seule étape, mais je vais d'abord essayer de faire fonctionner tout cela avec mes 2 étapes :lol:
Et puis au premier abord, ça me parait très compliqué d'intégrer des tris, de la pagination, du javascript,... dans la solution fournie par alain.

Voici quand même ma XSL d'origine qui va maintenant subir un petit lifting.

Code:

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Imports -->
  <xsl:import href="entete.xsl"/>
  <xsl:import href="entete2.xsl"/>
  <xsl:import href="multipage.xsl"/>
  <!-- Fin Imports -->
 
  <xsl:output method="html" encoding="ISO-8859-1" indent="yes"/>
 
  <!-- Parametres d entrees -->
  <xsl:param name="champTri"/>
  <xsl:param name="sensTri"/>
  <xsl:param name="nbEnregPage"/>
  <xsl:param name="noPage"/>
  <xsl:param name="fileName"/>
  <xsl:param name="modeRapatrie"/>
 
  <xsl:param name="refEntite"/>
  <xsl:param name="numCreation"/>
  <xsl:param name="refNoeud"/>
  <xsl:param name="environnement"/>
  <xsl:param name="refEtablissement"/>
  <xsl:param name="libelleReference"/>
  <xsl:param name="refReference"/>
  <xsl:param name="refCategEntite"/>
  <xsl:param name="methodeRetour"/>
  <xsl:param name="methodeRetourMulti"/>
  <xsl:param name="rapatrieSiUnSeul"/>
  <xsl:param name="autoriseCreation"/>
  <xsl:param name="bureau"/>
  <xsl:param name="modeCreConsult"/>
  <xsl:param name="lstNotIn"/>
  <xsl:param name="codeGroupeRech"/>
  <xsl:param name="reference"/>
  <xsl:param name="refRecherche"/>
  <xsl:param name="codeCategorie"/>
  <!-- Fin Parametres d entrees -->
 
  <!-- Template lien -->
  <xsl:template name="lien">
    <xsl:param name="refEntite"/>
    <xsl:choose>
      <!-- Si lien -->
      <xsl:when test="@lien='1'">
        <xsl:if test="$modeCreConsult='II' or $modeCreConsult='IE' or $modeCreConsult='I'">
          <td nowrap="true" class="lib"><a class="interne" href="javascript:lance('{$refEntite}')"><xsl:value-of select="."/></a></td>
        </xsl:if>
        <xsl:if test="$modeCreConsult!='II' and $modeCreConsult!='IE' and $modeCreConsult!='I'">
          <td nowrap="true" class="lib"><a class="externe" href="javascript:lance('{$refEntite}')"><xsl:value-of select="."/></a></td>
        </xsl:if>
      </xsl:when>
      <!-- Ne pas afficher les attributs masqués -->
      <xsl:when test="@visible='0' or name()='ID'">
      </xsl:when>
      <xsl:otherwise>
        <td nowrap="true" class="lib"><xsl:value-of select="."/></td>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <!-- Fin Template lien -->
 
  <!-- Template aplati -->
  <xsl:template name="aplati">
   <!-- Pour tous les fils sans fils -->
   <xsl:for-each select="*[count(*)=0]">
      <xsl:call-template name="lien"/>
   </xsl:for-each>
   <xsl:choose>
    <!-- Pour les Petits enfants -->
    <xsl:when test="count(*[count(*)!=0]) &gt; 1">
      <td>
        <table border="0" cellspacing="0" cellpadding="0">
        <xsl:for-each select="*">
          <tr>
          <xsl:call-template name="aplati"/>
          </tr>
        </xsl:for-each>
        </table>
      </td>
    </xsl:when>
    <xsl:when test="count(*[count(*)!=0]) = 1">
      <xsl:for-each select="*">
        <xsl:call-template name="aplati"/>
      </xsl:for-each>
    </xsl:when>
    <xsl:otherwise>
    </xsl:otherwise>
   </xsl:choose>
  </xsl:template>
  <!-- Fin Template aplati -->
 
  <xsl:template match="root">
  <html>
    <head>
      <script type="text/javascript" src="/astre/as/ep/arbre/js/fonctions.js"></script>
      <script type="text/javascript" src="/astre/as/commun/js/GestionBoutonsAS.js"></script>
      <script type="text/javascript" src="/astre/as/commun/js/boutonsStdAS.js"></script>
      <script type="text/javascript" src="/astre/as/commun/js/boutons.js"></script>
      <script type="text/javascript" src="/astre/as/commun/js/utile.js"></script>
      <script type="text/javascript" src="/astre/as/commun/js/ValidateChamps.js"></script>
 
      <script type="text/javascript" src="/astre/as/standard/recherche/js/FonctionRecherche.js"></script>
 
      <link rel="stylesheet" href="/astre/as/ihm/sable/css/reference.css" type="text/css"/>
      <link rel="stylesheet" href="/astre/as/ihm/sable/css/fondfiche.css" type="text/css"/>
 
      <title>Résultat de la recherche</title>
      <script type="text/javascript">
      <![CDATA[
        var _astre_as_path     = '/astre/as/';
        var _ihm_path          = '/astre/as/ihm/';
        var _ihm_path_btn      = '/astre/as/ihm/boutons/';
 
        var _ihm_theme         = 'sable';
        var _ihm_environnement = "<xsl:value-of select='$environnement'/>";
 
        function enableValider()
        {
          window.top.frames['Bas'].setBarreOutils(null,null,"MAJ",null);
        }
 
        function isFormOk()
        {
          return true;
        }
 
        function tailleEntete()
        {
          try {
            for (var i=0;i<parseInt(document.forms[0].NbColonne.value);i++)
            {
              try
              {
                var wCorps=document.getElementById("colCorps_"+i).offsetWidth;
                document.getElementById("colEntete_"+i).width=wCorps;
 
                wCorps-=21;
                document.getElementById("itEntete_"+i).style.width=wCorps;
              }
              catch(e) {}
            }
          } catch(e) {}
        }
 
        function surligne(trObj,out,classN)
        {
          trObj.className=(out?"tabFond2":classN);
        }
 
      ]]>
      </script>
    </head>
 
<body class="fond" style="overflow:auto;" onscroll="tailleEntete();" onresize="tailleEntete();" onLoad="tailleEntete(); init(); pageFocus('NoPage');" topmargin="0" leftmargin="0" bottommargin="0" rightmargin="0" marginheight="0" marginwidth="0">
<form name="frmTraitement"  action="/astre/as/standard/recherche/PriRechercheFIn.jsp" method="post">
 
    <!-- Variable  pour le multipage -->
    <xsl:variable name="nbTotal"><xsl:value-of select="count(*)"/></xsl:variable>
    <xsl:variable name="nbTotalPage"><xsl:value-of select="ceiling($nbTotal div $nbEnregPage)"/></xsl:variable>
 
    <input type="hidden" name="NbTotalEnreg" value="{$nbTotal}"/>
    <input type="hidden" name="NbTotalPage" value="{$nbTotalPage}"/>
 
    <!-- Déduire le premier enreg -->
    <xsl:variable name="enregFin">
      <xsl:choose>
        <xsl:when test="($noPage * $nbEnregPage) &gt; $nbTotal">
          <xsl:value-of select="$nbTotal"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$noPage * $nbEnregPage"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:variable name="enregDeb">
      <xsl:choose>
        <xsl:when test="$noPage = 1">
          <xsl:value-of select="'0'"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:choose>
            <xsl:when test="($noPage * $nbEnregPage) &gt; $nbTotal">
              <xsl:value-of select="($noPage - 1) * $nbEnregPage"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="$enregFin - $nbEnregPage + 1"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
 
    <input type="hidden" name="EnregDeb" value="{$enregDeb}"/>
    <input type="hidden" name="EnregFin" value="{$enregFin}"/>
 
    <xsl:variable name="nbAffiche"><xsl:value-of select="count(*[position() &gt; $enregDeb and position() &lt; $enregFin+1])"/></xsl:variable>
    <input type="hidden" name="NbAffiche" value="{$nbAffiche}"/>
    <!-- Fin Variable  pour le multipage -->
 
    <!-- Chargement Multi-page -->
    <xsl:call-template name="multipage">
      <xsl:with-param name="pNbTotalPage" select="$nbTotalPage"/>
    </xsl:call-template>
 
    <table width="100%" border="0" cellspacing="0" cellpadding="0" class="lib">
    <tr>
      <td><xsl:text disable-output-escaping="yes">&amp;nbsp;&amp;nbsp;</xsl:text></td>
      <td width="100%" class="tabBord">
 
 
    <table border="0" align="center" cellspacing="2" cellpadding="0">
 
    <!-- Chargement Entete -->
    <xsl:call-template name="entete"/>
    </table>
 
    <table border="0" cellspacing="2" cellpadding="0" width="100%">
    <xsl:call-template name="entete2"/>
 
<!-- Faire un tri différent selon que le champ à trier soit une date  -->
<!--!!! TEMPORAIRE !!!-->
<xsl:choose>
  <xsl:when test="contains(*/*[name()=$champTri],'/')">
 
    <!-- Pour Chaque ligne -->
    <xsl:for-each select="*">
      <xsl:sort select="concat(substring(*[name()=$champTri],7,4), substring(*[name()=$champTri],4,2), substring(*[name()=$champTri],1,2))" order="{$sensTri}"/>
 
      <!-- Variable -->
      <xsl:variable name="varID"><xsl:value-of select="ID"/></xsl:variable>
      <xsl:variable name="varLigne"><xsl:value-of select="position()"/></xsl:variable>
 
      <!-- Ne sélectionner que les n lignes souhaitées -->
      <xsl:if test="$varLigne &gt; $enregDeb and $varLigne &lt; $enregFin+1">
        <tr>
        <!-- Colorer une ligne sur 2 -->
        <xsl:if test="($varLigne mod 2)=0">
          <xsl:attribute name="class">lib fondBeige</xsl:attribute>
          <xsl:attribute name="onmouseover">surligne(this,true)</xsl:attribute>
          <xsl:attribute name="onmouseout">surligne(this,false,'lib fondBeige')</xsl:attribute>
        </xsl:if>
        <xsl:if test="($varLigne mod 2)!=0">
          <xsl:attribute name="class">lib</xsl:attribute>
          <xsl:attribute name="onmouseover">surligne(this,true)</xsl:attribute>
          <xsl:attribute name="onmouseout">surligne(this,false,'lib')</xsl:attribute>
        </xsl:if>
 
        <!-- Case à cocher de rapatriement -->
        <xsl:choose>
          <xsl:when test="$modeRapatrie=1">
            <td nowrap="true" width="1">
              <script>
              btnIconeTheme("coche_1_<xsl:value-of select="$varLigne"/>","b-radio","rapatrieSimple('<xsl:value-of select="$varLigne"/>')","Sélectionner cette valeur");
              </script>
            </td>
          </xsl:when>
          <xsl:when test="$modeRapatrie=2 or $modeRapatrie=9">
            <td nowrap="true" width="1">
              <script>
              btnStdCoche("coche_1_<xsl:value-of select="$varLigne"/>",0,null,null,"",false,"","b-select");
              </script>
            </td>
          </xsl:when>
          <xsl:otherwise>
          </xsl:otherwise>
        </xsl:choose>
 
        <!-- Pour chaque colonne -->
        <xsl:for-each select="*">
 
          <!-- Champs cachés -->
          <input type="hidden" name="value_{$varLigne}_{position()}" value="{self::node()}"/>
          <input type="hidden" name="name_{$varLigne}_{position()}" value="{name()}"/>
 
          <!-- Pas de fils -->
          <xsl:if test="count(*)=0">
            <xsl:call-template name="lien">
              <xsl:with-param name="refEntite" select="$varID"/>
            </xsl:call-template>
          </xsl:if>
          <xsl:if test="count(*)!=0">
            <xsl:call-template name="aplati"/>
          </xsl:if>
 
        </xsl:for-each>
 
        </tr>
      </xsl:if>
    </xsl:for-each>
 
</xsl:when>
<xsl:otherwise>
 
    <xsl:for-each select="*">
      <xsl:sort select="*[name()=$champTri]" order="{$sensTri}"/>
 
      <!-- Variable -->
      <xsl:variable name="varID"><xsl:value-of select="ID"/></xsl:variable>
      <xsl:variable name="varLigne"><xsl:value-of select="position()"/></xsl:variable>
 
      <!-- Ne sélectionner que les n lignes souhaitées -->
      <xsl:if test="$varLigne &gt; $enregDeb and $varLigne &lt; $enregFin+1">
        <tr>
        <!-- Colorer une ligne sur 2 -->
        <xsl:if test="($varLigne mod 2)=0">
          <xsl:attribute name="class">lib fondBeige</xsl:attribute>
          <xsl:attribute name="onmouseover">surligne(this,true)</xsl:attribute>
          <xsl:attribute name="onmouseout">surligne(this,false,'lib fondBeige')</xsl:attribute>
        </xsl:if>
        <xsl:if test="($varLigne mod 2)!=0">
          <xsl:attribute name="class">lib</xsl:attribute>
          <xsl:attribute name="onmouseover">surligne(this,true)</xsl:attribute>
          <xsl:attribute name="onmouseout">surligne(this,false,'lib')</xsl:attribute>
        </xsl:if>
 
        <!-- Case à cocher de rapatriement -->
        <xsl:choose>
          <xsl:when test="$modeRapatrie=1">
            <td nowrap="true" width="1">
              <script>
              btnIconeTheme("coche_1_<xsl:value-of select="$varLigne"/>","b-radio","rapatrieSimple('<xsl:value-of select="$varLigne"/>')","Sélectionner cette valeur");
              </script>
            </td>
          </xsl:when>
          <xsl:when test="$modeRapatrie=2 or $modeRapatrie=9">
            <td nowrap="true" width="1">
              <script>
              btnStdCoche("coche_1_<xsl:value-of select="$varLigne"/>",0,null,null,"",false,"","b-select");
              </script>
            </td>
          </xsl:when>
          <xsl:otherwise>
          </xsl:otherwise>
        </xsl:choose>
 
        <!-- Pour chaque colonne -->
        <xsl:for-each select="*">
 
          <!-- Champs cachés -->
          <input type="hidden" name="value_{$varLigne}_{position()}" value="{self::node()}"/>
          <input type="hidden" name="name_{$varLigne}_{position()}" value="{name()}"/>
 
          <!-- Pas de fils -->
          <xsl:if test="count(*)=0">
            <xsl:call-template name="lien">
              <xsl:with-param name="refEntite" select="$varID"/>
            </xsl:call-template>
          </xsl:if>
          <xsl:if test="count(*)!=0">
            <xsl:call-template name="aplati"/>
          </xsl:if>
 
        </xsl:for-each>
        </tr>
      </xsl:if>
    </xsl:for-each>
 
</xsl:otherwise>
</xsl:choose>
 
    </table>
 
 
      </td>
      <td><xsl:text disable-output-escaping="yes">&amp;nbsp;&amp;nbsp;</xsl:text></td>
    </tr>
    <tr>
      <td></td>
      <td>
  <table width="100%">
        <tr>
    <td align="left" class="tracabilite" width="60%">
      <script>document.write(((eval(document.forms[0].EnregDeb.value)==0)?1:document.forms[0].EnregDeb.value)+"-"+document.forms[0].EnregFin.value+" / "+document.forms[0].NbTotalEnreg.value + " éléments")</script>
    </td>
  </tr>
  </table>
      </td>
    </tr>
    </table>
 
 
 
</form>
</body>
</html>
  </xsl:template>
 
</xsl:stylesheet>

17/04/2007, 10h14
alain.couthures

Je pense effectivement qu'il est plus sain de travailler en plusieurs phases avec l'extension node-set pour retravailler le résultat...
17/04/2007, 10h19
GrandFather

Citation:

Envoyé par SONY30

Ton exemple ne fonctionne pas GrandFather, les éléments racines sont conservés.

C'est à dire ? Je viens de tester avec ton échantillon, et ça donne exactement le résultat souhaité.

Citation:

Envoyé par GrandFather

C'est à dire ? Je viens de tester avec ton échantillon, et ça donne exactement le résultat souhaité.

Voilà ce que j'obtiens pour l'exemple du post n°8

Code:

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
<ROOT>
   <S1>
      <lib>Structure 1</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 1</type>
 
            <B1>
 
               <lib>Budget 1</lib>
 
               <t>B</t>
 
            </B1>
 
            <B2>
 
               <lib>Budget 2</lib>
 
               <t>B</t>
 
            </B2>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 1</type>
 
         <B1>
 
            <lib>Budget 1</lib>
 
            <t>B</t>
 
         </B1>
 
         <B2>
 
            <lib>Budget 2</lib>
 
            <t>B</t>
 
         </B2>
 
      </SEC1>
      <type>Type 1</type>
      <lib>Budget 1</lib>
   </S1>
   <S1>
      <lib>Structure 1</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 1</type>
 
            <B1>
 
               <lib>Budget 1</lib>
 
               <t>B</t>
 
            </B1>
 
            <B2>
 
               <lib>Budget 2</lib>
 
               <t>B</t>
 
            </B2>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 1</type>
 
         <B1>
 
            <lib>Budget 1</lib>
 
            <t>B</t>
 
         </B1>
 
         <B2>
 
            <lib>Budget 2</lib>
 
            <t>B</t>
 
         </B2>
 
      </SEC1>
      <type>Type 1</type>
      <lib>Budget 2</lib>
   </S1>
   <S1>
      <lib>Structure 1</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 2</type>
 
            <B1>
 
               <lib>Budget 3</lib>
 
               <t>B</t>
 
            </B1>
 
            <B2>
 
               <lib>Budget 4</lib>
 
               <t>B</t>
 
            </B2>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 2</type>
 
         <B1>
 
            <lib>Budget 3</lib>
 
            <t>B</t>
 
         </B1>
 
         <B2>
 
            <lib>Budget 4</lib>
 
            <t>B</t>
 
         </B2>
 
      </SEC1>
      <type>Type 2</type>
      <lib>Budget 3</lib>
   </S1>
   <S1>
      <lib>Structure 1</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 2</type>
 
            <B1>
 
               <lib>Budget 3</lib>
 
               <t>B</t>
 
            </B1>
 
            <B2>
 
               <lib>Budget 4</lib>
 
               <t>B</t>
 
            </B2>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 2</type>
 
         <B1>
 
            <lib>Budget 3</lib>
 
            <t>B</t>
 
         </B1>
 
         <B2>
 
            <lib>Budget 4</lib>
 
            <t>B</t>
 
         </B2>
 
      </SEC1>
      <type>Type 2</type>
      <lib>Budget 4</lib>
   </S1>
   <S2>
      <lib>Structure 2</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 1</type>
 
            <B5>
 
               <lib>Budget 5</lib>
 
               <t>B</t>
 
            </B5>
 
            <B6>
 
               <lib>Budget 6</lib>
 
               <t>B</t>
 
            </B6>
 
            <B7>
 
               <lib>Budget 7</lib>
 
               <t>B</t>
 
            </B7>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 1</type>
 
         <B5>
 
            <lib>Budget 5</lib>
 
            <t>B</t>
 
         </B5>
 
         <B6>
 
            <lib>Budget 6</lib>
 
            <t>B</t>
 
         </B6>
 
         <B7>
 
            <lib>Budget 7</lib>
 
            <t>B</t>
 
         </B7>
 
      </SEC1>
      <type>Type 1</type>
      <lib>Budget 5</lib>
   </S2>
   <S2>
      <lib>Structure 2</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 1</type>
 
            <B5>
 
               <lib>Budget 5</lib>
 
               <t>B</t>
 
            </B5>
 
            <B6>
 
               <lib>Budget 6</lib>
 
               <t>B</t>
 
            </B6>
 
            <B7>
 
               <lib>Budget 7</lib>
 
               <t>B</t>
 
            </B7>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 1</type>
 
         <B5>
 
            <lib>Budget 5</lib>
 
            <t>B</t>
 
         </B5>
 
         <B6>
 
            <lib>Budget 6</lib>
 
            <t>B</t>
 
         </B6>
 
         <B7>
 
            <lib>Budget 7</lib>
 
            <t>B</t>
 
         </B7>
 
      </SEC1>
      <type>Type 1</type>
      <lib>Budget 6</lib>
   </S2>
   <S2>
      <lib>Structure 2</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 1</type>
 
            <B5>
 
               <lib>Budget 5</lib>
 
               <t>B</t>
 
            </B5>
 
            <B6>
 
               <lib>Budget 6</lib>
 
               <t>B</t>
 
            </B6>
 
            <B7>
 
               <lib>Budget 7</lib>
 
               <t>B</t>
 
            </B7>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 1</type>
 
         <B5>
 
            <lib>Budget 5</lib>
 
            <t>B</t>
 
         </B5>
 
         <B6>
 
            <lib>Budget 6</lib>
 
            <t>B</t>
 
         </B6>
 
         <B7>
 
            <lib>Budget 7</lib>
 
            <t>B</t>
 
         </B7>
 
      </SEC1>
      <type>Type 1</type>
      <lib>Budget 7</lib>
   </S2>
   <S2>
      <lib>Structure 2</lib>
      <Z>
 
         <SEC1>
 
            <type>Type 2</type>
 
            <B8>
 
               <lib>Budget 8</lib>
 
               <t>B</t>
 
            </B8>
 
         </SEC1>
 
      </Z>
      <SEC1>
 
         <type>Type 2</type>
 
         <B8>
 
            <lib>Budget 8</lib>
 
            <t>B</t>
 
         </B8>
 
      </SEC1>
      <type>Type 2</type>
      <lib>Budget 8</lib>
   </S2>
</ROOT>

17/04/2007, 10h29
alain.couthures

Moi, ce que je vois, plutôt, c'est que, pour le dernier exemple fourni, l'élément <t>B</t> n'apparait pas dans le résultat ...?

En tout cas, j'apprécie le style "ramassé" de la solution proposée !

Citation:

Envoyé par SONY30

Voilà ce que j'obtiens pour l'exemple du post n°8

Gné ? C'est la copie conforme de la source XML ! 8O

Moi j'obtiens bien ceci :

Code:

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
<?xml version="1.0" encoding="UTF-8"?>
<ROOT>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 1</type>
        <lib>Budget 1</lib>
    </S1>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 1</type>
        <lib>Budget 2</lib>
    </S1>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 2</type>
        <lib>Budget 3</lib>
    </S1>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 2</type>
        <lib>Budget 4</lib>
    </S1>
    <S2>
        <lib>Structure 2</lib>
        <type>Type 1</type>
        <lib>Budget 5</lib>
    </S2>
    <S2>
        <lib>Structure 2</lib>
        <type>Type 1</type>
        <lib>Budget 6</lib>
    </S2>
    <S2>
        <lib>Structure 2</lib>
        <type>Type 1</type>
        <lib>Budget 7</lib>
    </S2>
    <S2>
        <lib>Structure 2</lib>
        <type>Type 2</type>
        <lib>Budget 8</lib>
    </S2>
</ROOT>

17/04/2007, 10h47
SONY30

Pas exactement mais ils sont très proches... Bizarre...
Je trouve ce même résultat que je fasse la transformation avec "Exchanger XSLT debugger" ou par composant Java (Xalan)
Je comprends pas là.

Edit : Alain a l'air de trouver la même chose que toi avec ta solution.
17/04/2007, 11h18
alain.couthures

OK, j'avoue... J'utilise le framework .Net 2.0 ...

D'un point de vue support XSLT 1.0 et XPath 1.0, même si ça a été laborieux, je crois, quand même, que M$ a réussi à corriger ses bugs et je n'ai pas de souci avec. Alors, comme il est, en plus, très rapide !

Vu la disponibilité et l'efficacité des intervenants je me permets une autre question.
Soit donc le fichier XML résultat sous cette forme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?xml version="1.0" encoding="UTF-8"?>
<ROOT>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 1</type>
        <lib>Budget 1</lib>
        <truc>Val truc</truc>
    </S1>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 1</type>
        <lib>Budget 2</lib>
        <machin>val machin</machin>
    </S1>
    <S1>
        <lib>Structure 1</lib>
        <type>Type 2</type>
        <lib>Budget 3</lib>
        <truc>Val truc</truc>
        <machin>val machin</machin>
        <bidule>val bidule</bidule>
    </S1>
</ROOT>

auquel j'applique grosso modo la transformation suivante

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" indent="yes"/>
 
<xsl:template match="ROOT">
   <table>
   <xsl:for-each select="*">
   	<tr>
	   	<xsl:for-each select="*">
	    	<td><xsl:value-of select="."/></td>    	
		</xsl:for-each>
	</tr>
   </xsl:for-each>
   </table>
</xsl:template>
 
</xsl:stylesheet>

Je souhaiterais qu'au niveau de mon HTML soit présenté tous les TD, en l'occurence représenter les 6 éléments.
En gros ce serait de récupérer le paquet (<S>) possédant le plus d'éléments, et comparer la position des élèments de chaque paquet avec les éléments du paquet possédant le plus d'élèments...

Voilà, en pas trop de lignes, ma proposition :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<xsl:stylesheet version="1.0" txs:name="rendu">
 <xsl:template match="/">
  <table>
   <xsl:for-each select="/ROOT/*">
    <xsl:sort select="count(*)" order="descending"/>
    <xsl:if test="position()=1">
     <xsl:variable name="lemax" select="."/>
     <xsl:for-each select="/ROOT/*">
      <xsl:variable name="cur" select="."/>
      <tr>
       <xsl:for-each select="$lemax/*">
        <xsl:variable name="n" select="name()"/>
        <td>
         <xsl:value-of select="$cur/*[name()=$n]"/>
        </td>
       </xsl:for-each>
      </tr>
     </xsl:for-each>
    </xsl:if>
   </xsl:for-each>
  </table>
 </xsl:template>
</xsl:stylesheet>

(testé avec http://www.agencexml.com/txs/fr/)

Il ne serait pas dur d'y rajouter une ligne de titre pour les colonnes...

Cela fonctionne bien, j'ai réussi à intégrer mes spécificités (tri, pagination, javascript, mise en page) sans problèmes. :king:

Par contre concernant la première transformation (post n°9) une spécificité de mon XML pose problème. Si j'ai un noeud de regroupement d'information (<adresse> dans l'exemple ci-dessous), il me retourne 2 lignes au lieu d'une seule.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 <ROOT> <Structure> <ID>|D_STRUCT070000000001|1|</ID> <Libelle-de-la-structure>Séb</Libelle-de-la-structure> <adresse> <cp>34000</cp> <distrib>Montpellier</distrib> </adresse> <exercice> <annee>2006</annee> <section> <type>H</type> <budget> <lib>Budget Séb</lib> <t>B</t> </budget> </section> </exercice> </Structure> </ROOT>
En rajoutant cette condition dans le select ça fonctionne mais bon...

Code:

select="//*[count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and name(parent::*)!='adresse' and count(following-sibling::*[count(*)!=0])=0]"

18/04/2007, 13h43
alain.couthures
En fait, il y a deux points à améliorer :
- n'appliquer le template qu'aux feuilles les plus hautes (si on remet l'arbre debout!) et pour ça on rejoint le second algo
- ramasser tous les sous-noeuds texte des ancètres par template
Je m'y remets dès que j'ai le temps pour !

Voici une nouvelle version...
Elle est à tester car elle comporte une restriction pour ne pas être trop compliquée : les noms des noeuds doivent être réguliers à une profondeur donnée, ce qui semble bien être le cas dans le dernier exemple fourni :

Code:

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
<xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:variable name="deepest">
    <xsl:for-each select="//*[count(*)=0]">
     <xsl:sort select="count(ancestor::*)" order="descending"/>
     <xsl:if test="position() = 1">
      <xsl:value-of select="count(ancestor::*)"/>
     </xsl:if>
    </xsl:for-each>
   </xsl:variable>
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:apply-templates mode="aplat" select="//*[count(ancestor::*)=$deepest and count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
    <xsl:variable name="next" select="name(ancestor::*[position()=$p - 1])"/>
    <xsl:choose>
     <xsl:when test="$p = 1">
      <xsl:copy-of select="ancestor::*[1]/*[text()!='']"/>
     </xsl:when>
     <xsl:when test="$p = count(ancestor::*) -1">
      <xsl:element name="{name(ancestor::*[position()=$p])}">
       <xsl:copy-of select="ancestor::*[position()=$p]/@*"/>
       <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
       <xsl:call-template name="aplati">
        <xsl:with-param name="p" select="$p - 1"/>
       </xsl:call-template>
      </xsl:element>
     </xsl:when>
     <xsl:otherwise>
      <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
      <xsl:call-template name="aplati">
       <xsl:with-param name="p" select="$p - 1"/>
      </xsl:call-template>
     </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <xsl:template match="*" mode="ramasse">
   <xsl:choose>
    <xsl:when test="count(*)=0 and text()!=''">
     <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="count(*)!=0">
     <xsl:apply-templates select="*" mode="ramasse"/>
    </xsl:when>
   </xsl:choose>
  </xsl:template>
 </xsl:stylesheet>

Il faut que la profondeur max des éléments text soit la même pour toutes les lignes.
Il arrive à gérer ce XML

Code:

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
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
  <adresse>
  	<cp>34000</cp>
  	<distrib>Montpellier</distrib>
  </adresse>
  <exercice>
  	<annee>2006</annee>
  	<section>
  		<type>H</type>
  		<budget>
  			<lib>Budget Séb</lib>
  			<t>B</t>
  		</budget>
  	</section>
  </exercice> 
</Structure>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Tib</Libelle-de-la-structure>
  <exercice>
  	<annee>2006</annee>
  	<section>
  		<type>H</type>
  		<budget>
  			<lib>Budget Tib</lib>
  			<t>B</t>
  		</budget>
  	</section>
  </exercice>  
</Structure>
</ROOT>

Mais pas celui-ci pour lequel il fait sauter une ligne.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
  <adresse>
  	<cp>34000</cp>
  	<distrib>Montpellier</distrib>
  </adresse>
</Structure>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Tib</Libelle-de-la-structure>
</Structure>
</ROOT>

Bon, ça devient de plus en plus hard !

Mais pas encore désespéré, il suffit de descendre le traitement à chaque enfant de la racine...

Code:

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
 <xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:for-each select="*">
      <xsl:variable name="deepest">
       <xsl:for-each select="descendant::*[count(*)=0]">
        <xsl:sort select="count(ancestor::*)" order="descending"/>
        <xsl:if test="position() = 1">
         <xsl:value-of select="count(ancestor::*)"/>
        </xsl:if>
       </xsl:for-each>
      </xsl:variable>
      <xsl:apply-templates mode="aplat" select="//*[count(ancestor::*)=$deepest and count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
     </xsl:for-each>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
    <xsl:variable name="next" select="name(ancestor::*[position()=$p - 1])"/>
    <xsl:choose>
     <xsl:when test="$p = count(ancestor::*) -1">
      <xsl:element name="{name(ancestor::*[position()=$p])}">
       <xsl:copy-of select="ancestor::*[position()=$p]/@*"/>
       <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
       <xsl:if test="$p != 1">
        <xsl:call-template name="aplati">
         <xsl:with-param name="p" select="$p - 1"/>
        </xsl:call-template>
       </xsl:if>
      </xsl:element>
     </xsl:when>
     <xsl:when test="$p = 1">
      <xsl:copy-of select="ancestor::*[1]/*[text()!='']"/>
     </xsl:when>
     <xsl:otherwise>
      <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
      <xsl:call-template name="aplati">
       <xsl:with-param name="p" select="$p - 1"/>
      </xsl:call-template>
     </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <xsl:template match="*" mode="ramasse">
   <xsl:choose>
    <xsl:when test="count(*)=0 and text()!=''">
     <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="count(*)!=0">
     <xsl:apply-templates select="*" mode="ramasse"/>
    </xsl:when>
   </xsl:choose>
  </xsl:template>
 </xsl:stylesheet>

Au passage, j'ai corrigé un bug sur la gestion du cas particulier de profondeur 2.

Cette feuille de style rajoute une contrainte supplémentaire: la profondeur max doit être identique pour chaque sous-noeud de la racine ou, sinon, on a un sous-noeud distinct.

Désolé... :cry:

Cela fonctionne maintenant sur ce cas

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
  <adresse>
  	<cp>34000</cp>
  	<distrib>Montpellier</distrib>
  </adresse>
</Structure>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Tib</Libelle-de-la-structure>
</Structure>
</ROOT>

mais plus sur celui-là

Code:

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
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
  <adresse>
  	<cp>34000</cp>
  	<distrib>Montpellier</distrib>
  </adresse>
  <exercice>
  	<annee>2006</annee>
  	<section>
  		<type>H</type>
  		<budget>
  			<lib>Budget Séb</lib>
  			<t>B</t>
  		</budget>
  	</section>
  </exercice> 
</Structure>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Tib</Libelle-de-la-structure>
  <exercice>
  	<annee>2006</annee>
  	<section>
  		<type>H</type>
  		<budget>
  			<lib>Budget Tib</lib>
  			<t>B</t>
  		</budget>
  	</section>
  </exercice>  
</Structure>
</ROOT>

ni sur celui là pour lequel il fait un produit cartésien

Code:

1
2
3
4
5
6
7
8
9
10
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
</Structure>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Tib</Libelle-de-la-structure>
</Structure>
</ROOT>

J'ai encore la joue toute rouge de la baffe que je viens de me mettre... Je suis trop étourdi : il ne faut plus utiliser "//" mais "descendant::" et j'avais oublié de reporter cette modification dans l'apply-templates :

Code:

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
 <xsl:stylesheet version="1.0" txs:name="aplati">
  <xsl:template match="/">
   <xsl:for-each select="*">
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <xsl:for-each select="*">
      <xsl:variable name="deepest">
       <xsl:for-each select="descendant::*[count(*)=0]">
        <xsl:sort select="count(ancestor::*)" order="descending"/>
        <xsl:if test="position() = 1">
         <xsl:value-of select="count(ancestor::*)"/>
        </xsl:if>
       </xsl:for-each>
      </xsl:variable>
      <xsl:apply-templates mode="aplat" select="descendant::*[count(ancestor::*)=$deepest and count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
     </xsl:for-each>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
  <xsl:template name="aplati">
   <xsl:param name="p"/>
    <xsl:variable name="next" select="name(ancestor::*[position()=$p - 1])"/>
    <xsl:choose>
     <xsl:when test="$p = count(ancestor::*) -1">
      <xsl:element name="{name(ancestor::*[position()=$p])}">
       <xsl:copy-of select="ancestor::*[position()=$p]/@*"/>
       <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
       <xsl:if test="$p != 1">
        <xsl:call-template name="aplati">
         <xsl:with-param name="p" select="$p - 1"/>
        </xsl:call-template>
       </xsl:if>
      </xsl:element>
     </xsl:when>
     <xsl:when test="$p = 1">
      <xsl:copy-of select="ancestor::*[1]/*[text()!='']"/>
     </xsl:when>
     <xsl:otherwise>
      <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
      <xsl:call-template name="aplati">
       <xsl:with-param name="p" select="$p - 1"/>
      </xsl:call-template>
     </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <xsl:template match="*" mode="ramasse">
   <xsl:choose>
    <xsl:when test="count(*)=0 and text()!=''">
     <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="count(*)!=0">
     <xsl:apply-templates select="*" mode="ramasse"/>
    </xsl:when>
   </xsl:choose>
  </xsl:template>
 </xsl:stylesheet>

Chapeau l'artiste :king:

Juste une dernière question pour la route 8-)
J'ai intégré dans le XSL permettant de transformer mon XML à plat en tableau HTML, un tri. Ce tri ne fonctionnant pas sur les dates j'ai donc conditionné ma boucle <for-each> c'est vraiment pas terrible mais ça marche, à première vu comme ça, est-il faisable de faire plus propre ?

Code:

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
 <xsl:template match="/">
  <table>
   <xsl:for-each select="/root/*">
    <xsl:sort select="count(*[not(@visible) and name()!='ID'])" order="descending"/>
    <xsl:if test="position()=1">
     <xsl:variable name="lemax" select="."/>
 
	<xsl:choose>
	<xsl:when test="contains(*/*[name()=$champTri],'/')">     
 
     <xsl:for-each select="/root/*">
      <xsl:sort select="concat(substring(*[name()=$champTri],7,4), substring(*[name()=$champTri],4,2), substring(*[name()=$champTri],1,2))" order="{$sensTri}"/>
      <xsl:variable name="cur" select="."/>
      <tr>
       <xsl:for-each select="$lemax/*">
        <xsl:variable name="n" select="name()"/>
        <xsl:if test="not(@visible)">
        <td>
         <xsl:value-of select="$cur/*[name()=$n]"/>
        </td>
        </xsl:if>
       </xsl:for-each>
      </tr>
     </xsl:for-each>
 
    </xsl:when>
    <xsl:otherwise>
 
     <xsl:for-each select="/root/*">
      <xsl:sort select="*[name()=$champTri]" order="{$sensTri}"/>
      <xsl:variable name="cur" select="."/>
      <tr>
       <xsl:for-each select="$lemax/*">
        <xsl:variable name="n" select="name()"/>
        <xsl:if test="not(@visible)">
        <td>
         <xsl:value-of select="$cur/*[name()=$n]"/>
        </td>
        </xsl:if>
       </xsl:for-each>
      </tr>
     </xsl:for-each>
 
    </xsl:otherwise>
    </xsl:choose>
 
    </xsl:if>
   </xsl:for-each>
  </table>
 </xsl:template>

Encore merci et bravo:king: , si je peux vous être utile pour quoique ce soit, n'hésitez pas.

Bonjour à tous, depuis une petite heure, je suis en train de me battre à aplatir un arbre, mais je n'y arrive jamais totalement.

Il faut que je passe de ça :

Code:

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
<?xml version="1.0" encoding="ISO-8859-1"?> 
 
<a v="a1">
 
	<b v="b1">
 
		<c v="c1"></c>
 
		<c v="c2"></c>
 
	</b>
 
	<b v="b2">
 
		<c v="c3"></c>
 
	</b>
 
	<b v="b3">
 
		<c v="c4"></c>
 
		<c v="c5"></c>
 
	</b>
 
	<b v="b4">
 
		<c v="c6"></c>
 
	</b>
 
</a>

à ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?xml version="1.0" encoding="ISO-8859-1"?> 
 
<a v="a1"></a>
 
<b v="b1"></b>
 
<c v="c1"></c>
 
<c v="c2"></c>
 
<b v="b2"></b>
 
<c v="c3"></c>
 
<b v="b3"></b>
 
<c v="c4"></c>
 
<c v="c5"></c>
 
<b v="b4"></b>
 
<c v="c6"></c>

Avec 3 templates, j'arrive à récupérer les 3 séparément, mais jamais ensembles.

Merci de votre aide, @+

Le résultat souhaité n'est pas un document bien formé car il n'a pas de racine : il s'agit d'un fragment... Est-ce vraiment ce que vous souhaitez ?

Voilà une transformation avec racine :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 <xsl:stylesheet version="1.0" txs:name="casse"> <xsl:template match="/"> <root> <xsl:apply-templates/> </root> </xsl:template> <xsl:template match="@*|*"> <xsl:copy> <xsl:apply-templates select="@*"/> </xsl:copy> <xsl:apply-templates/> </xsl:template> </xsl:stylesheet>

21/04/2007, 16h14
davromaniak

Oui, c'est le parcours en profondeur d'un arbre.

J'te remercie.

@+

Me revoilà 3 mois après...

Le XSL proposé par Alain me pose un problème si j'ai plusieurs racines de même profondeur maximale, il me double la ligne de résultat...

:cry:

Edit : la racine la plus profonde ne doit pas être la référence.
L'évènement déclencheur de la création d'une nouvelle ligne, sera la présence de racines qui ont des frères.

Code:

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
72
73
74
75
76
77
78
79
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="ISO-8859-1" indent="yes"/>
 
  <xsl:template match="/">
   <!-- Pour le noeud racine -->
   <xsl:for-each select="*">
    <!-- Copie des attributs -->
    <xsl:element name="{name()}">
     <xsl:for-each select="@*">
      <xsl:copy/>
     </xsl:for-each>
     <!-- Pour chaque noeud fils -->
     <xsl:for-each select="*">
      <!-- RECUPERATION PROFONDEUR MAXIMALE -->
      <xsl:variable name="deepest">
       <!-- Pour tous les descendants qui n'ont pas de fils -->
       <xsl:for-each select="descendant::*[count(*)=0]">
        <!-- Trié par ordre décroissant -->
        <xsl:sort select="count(ancestor::*)" order="descending"/>
        <!-- Je récupère le premier (le plus profond) -->
        <xsl:if test="position() = 1">
         <xsl:value-of select="count(ancestor::*)"/>
        </xsl:if>
       </xsl:for-each>
      </xsl:variable>
      <!-- FIN RECUPERATION PROFONDEUR MAXIMALE -->
      <xsl:apply-templates mode="aplat" select="descendant::*[count(ancestor::*)=$deepest and count(*)=0 and count(preceding-sibling::*[count(*)=0])=0 and count(preceding-sibling::*[count(*)!=0])=0 and count(following-sibling::*[count(*)!=0])=0]"/>
     </xsl:for-each>
    </xsl:element>
   </xsl:for-each>
  </xsl:template>
 
  <xsl:template match="*" mode="aplat">
   <xsl:call-template name="aplati">
    <xsl:with-param name="p" select="count(ancestor::*) - 1"/>
   </xsl:call-template>
  </xsl:template>
 
  <xsl:template name="aplati">
   <xsl:param name="p"/>
    <xsl:variable name="next" select="name(ancestor::*[position()=$p - 1])"/>
    <xsl:choose>
     <xsl:when test="$p = count(ancestor::*) -1">
      <xsl:element name="{name(ancestor::*[position()=$p])}">
       <xsl:copy-of select="ancestor::*[position()=$p]/@*"/>
       <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
       <xsl:if test="$p != 1">
        <xsl:call-template name="aplati">
         <xsl:with-param name="p" select="$p - 1"/>
        </xsl:call-template>
       </xsl:if>
      </xsl:element>
     </xsl:when>
     <xsl:when test="$p = 1">
      <xsl:copy-of select="ancestor::*[1]/*[text()!='']"/>
     </xsl:when>
     <xsl:otherwise>
      <xsl:apply-templates mode="ramasse" select="ancestor::*[position()=$p]/*[name() != $next]"/>
      <xsl:call-template name="aplati">
       <xsl:with-param name="p" select="$p - 1"/>
      </xsl:call-template>
     </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
 
  <xsl:template match="*" mode="ramasse">
   <xsl:choose>
    <!--<xsl:when test="count(*)=0 and text()!=''">-->
    <xsl:when test="count(*)=0">
     <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="count(*)!=0">
     <xsl:apply-templates select="*" mode="ramasse"/>
    </xsl:when>
   </xsl:choose>
  </xsl:template>
 
</xsl:stylesheet>

Code:

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
<?xml version="1.0" encoding="UTF-8"?>
<ROOT>
<Structure>
  <ID>|D_STRUCT070000000001|1|</ID>
  <Libelle-de-la-structure>Séb</Libelle-de-la-structure>
  <adresse>
    <cp>34000</cp>
    <distrib>Montpellier</distrib>
  </adresse>
  <exercice>
    <annee>2006</annee>
    <section>
      <type>H</type>
      <budget>
        <lib>Budget Séb</lib>
        <t>B</t>
      </budget>
    </section>
  </exercice> 
  <racine>
    <test>
      <retest>
        <lib>TEST</lib>
      </retest>
    </test>    
  </racine>  
</Structure>
</ROOT>