[xsl]simuler le mecanisme OO de "liaison dynamique"

Version imprimable

Bonjour,

Mettons que j'ai le fichier XML suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 <animal race="mamifere"> <nom>chat</nom> <temperature_interne>36</temperature_interne> </animal> <animal race="mamifere"> <nom>chien</nom> <temperature_interne>35</temperature_interne> </animal> <animal race="mamifere"> <nom>baleine</nom> <temperature_interne>40</temperature_interne> </animal> <animal race="reptile"> <nom>tortue</nom> </animal> <animal race="poisson"> <nom>saumon</nom> </animal> <animal race="poisson"> <nom>brochet</nom> </animal>
Le principe est que tous mes animaux ont un nom, mais seuls les mamiferes ont une temperature interne. Je voudrais afficher tous mes animaux de le même façon dans une liste, mais dans le cas particulier des mamiferes afficher en plus leur temperature. Tout cela en evitant les xsl:when et xsl:if. L'equivalent en poo serait un classe animal possedant une methode toList() qui afficherait le nom. Cette methode serait redefinie dans la sous-classe mamifere qui appelerai d'abord la methode heritée (super.toList() en java, inherited en Delphi) avant d'afficher la temperature.

Voilà ce que j'obtiens si j'essaie de faire l'équivalent en XSL :
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"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="animaux"> <HTML> <HEAD> <TITLE>Document Title</TITLE> </HEAD> <BODY> <UL> <xsl:apply-templates/> </UL> </BODY> </HTML> </xsl:template> <xsl:template match="animal"> <LI> <xsl:value-of select="nom"/> </LI> </xsl:template> <xsl:template match="animal[@race='mamifere']"> <LI> <xsl:value-of select="nom"/> <xsl:value-of select="temperature_interne"/> </LI> </xsl:template> </xsl:stylesheet>
J'obtiens bien un comportement specifique pour les mamiferes, mais la ligne "<xsl:value-of select="nom"/>" qui est commune est répétée deux fois. Autrement dit, je n'arrive pas à faire l'équivalent à ce qui serait un appel à la methode heritée en poo (super.xxx() ou inherited).

Des pistes ?

Phil

PS : désolé pour l'exemple idiot... :wink:

Re: [xsl]simuler le mecanisme OO de "liaison dynamique&

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
<xsl:template match="animal">
<li>
    <xsl:apply-templates/>
</li>
</xsl:template>
 
<xsl:template match="nom">
    <xsl:value-of select="."/>
</xsl:template>
 
<xsl:template match="temperature_interne">
    <xsl:value-of select="."/>
</xsl:template>

par exemple

11/12/2003, 13h44
philemon_siclone

Merci pour la réponse, mais ça ne repond pas vraiment à la question puisque ton code reviens à dire :
Pour tout animal :
- dès qu'il y a un nom, alors on l'affiche
- dès qu'il y a une temperature interne, alors on l'affiche

Ce qui fait complètement abstraction du contexte (en poo, la "cible" ou le "receveur"; dans l'exemple la race de l'animal).
Le but du polymorphisme et de la liaison dynamique en poo est de pouvoir rajouter une sous-classe sans impacter le code existant. Je veux pouvoir faire l'équivalent ici, c'est à dire ajouter une race ayant une methode d'affichage spécifique sans impacter mes "templates" existantes. Par exemple : une race "oiseau" contenant un element nom et un element "couleur bec" qui quand on l'affiche, affiche uniquement la couleur du bec (et pas le nom). Avec ton code, ça ne marche pas.

Je précise que je ne cherche pas une solution à cet exemple particulier. Mais une solution de type "design pattern xsl".

Merci tout de même,

Phil
11/12/2003, 19h51
mathieu

j'aurais comme solution de faire autant de bloc que de race différente (dans le genre classe abstraite)

mais cette solution ne répond pas encore à ta question d'accès à "super"
le problème c'est que je ne vois pas trop ce que tu veux faire parce que pour moi la classe est représentéee par le nom de la balise (ici "animal") et que cette classe n'hérite d'aucune autre
est ce que tu pourrais nous montrer un autre exemple et ce que tu as envie de faire même si tu dois inventer des nouvelles commandes (fais comme chez toi ;) )
12/12/2003, 09h48
philemon_siclone

Citation:

j'aurais comme solution de faire autant de bloc que de race différente (dans le genre classe abstraite)

As-tu jeté un oeil à la solution (enfin au "debut de solution", sinon ce post n'aurait pas lieu d'être) qui figure dans mon premier post? Elle me semble déjà plus avancée que ce que tu proposes ci-dessus puisqu'il s'agit de l'équivalent d'un super-classe concrete (il y a un comportement par defaut qui est l'affichage du nom). Donc il n'est pas necessaire de faire autant de bloc que de race, on peut avoir un bloc par defaut.

Citation:

pour moi la classe est représentéee par le nom de la balise

C'est une interpretation... (courante, il est vrai). Mais rien n'empêche de dire que cette même balise accompagné d'un attribut represente une sous-classe.

En tout cas, merci beaucoup de t'interesser à mon problème. Et je vais essayer de reflechir à un autre exemple (peut-être plus proche de ce que je veux faire en réalité (c'est vrai que l'exemple des animaux est pê un peu simpliste)).

Phil

Autre piste

salut,

Voilà une autre piste : il est possible d'afficher les noms de mamifères et leut température interne sans spécifier l'attribut "race" dans le fichier Xml.

animaux.xml (sans attribut 'race') :

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
 
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet type="text/xsl" href="animaux.xsl"?>
<animaux>
	<animal> 
		<nom>chat</nom> 
		<temperature_interne>36</temperature_interne> 
	</animal> 
	<animal> 
		<nom>chien</nom> 
		<temperature_interne>35</temperature_interne> 
	</animal> 
	<animal> 
		<nom>baleine</nom> 
		<temperature_interne>40</temperature_interne> 
	</animal> 
	<animal> 
		<nom>tortue</nom> 
	</animal> 
	<animal> 
		<nom>saumon</nom> 
	</animal> 
	<animal> 
		<nom>brochet</nom> 
	</animal>
</animaux>

et animaux.xsl

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
 
<?xml version="1.0" encoding="iso-8859-1"?> 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
<xsl:template match="/"> 
 
	<html> 
	<head> 
	<title>Exemple</title> 
	</head> 
	<body>
	<h1>Mamifères</h1> 
	<ul>
	<xsl:apply-templates select="//animal/temperature_interne"/>
	</ul>
	</body> 
	</html> 
 
</xsl:template>
 
<xsl:template match="animal/temperature_interne">
	<li><xsl:value-of select="preceding-sibling::*"/>, <xsl:value-of select="."/></li>
</xsl:template> 
 
</xsl:stylesheet>

Zr.

meilleuer solution

Si on garde l'attribut 'race' dans le fichier animaux.xml, la solution optimale et la plus performante (en particulier dans des fichiers volumineux) est l'utilisation de clés :

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
 
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet type="text/xsl" href="animaux.xsl"?>
<animaux>
	<animal race="mamifere"> 
		<nom>chat</nom> 
		<temperature_interne>36</temperature_interne> 
	</animal> 
	<animal race="mamifere"> 
		<nom>chien</nom> 
		<temperature_interne>35</temperature_interne> 
	</animal> 
	<animal race="mamifere"> 
		<nom>baleine</nom> 
		<temperature_interne>40</temperature_interne> 
	</animal> 
	<animal race="reptile"> 
		<nom>tortue</nom> 
	</animal> 
	<animal race="poisson"> 
		<nom>saumon</nom> 
	</animal> 
	<animal race="poisson"> 
		<nom>brochet</nom> 
	</animal>
</animaux>

animaux.xsl :

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
 
<?xml version="1.0" encoding="iso-8859-1"?> 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
<xsl:key name="genre" match="animal" use="@race"/>
<xsl:output method="html"/>
 
<xsl:template match="/"> 
 
	<html> 
	<head> 
	<title>Exemple</title> 
	</head> 
	<body>
	<h1>Mamifères</h1> 
	<ul>
	<xsl:for-each select="key('genre', 'mamifere')">
		<li><xsl:copy-of select="."/></li>
	</xsl:for-each>
	</ul>
	</body> 
	</html> 
 
</xsl:template>
 
</xsl:stylesheet>

Zr.

J'ai ptet une solution:

le 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
 
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet type="text/xsl" href="C:\Dokumente und Einstellungen\Gtm\Eigene Dateien\delphi\components\xml\tmp\Untitled2.xsl"?>
<animaux>
	<animal race="mamifere">
		<nom>chat</nom>
		<temperature_interne>36</temperature_interne>
	</animal>
	<animal race="mamifere">
		<nom>chien</nom>
		<temperature_interne>35</temperature_interne>
	</animal>
	<animal race="mamifere">
		<nom>baleine</nom>
		<temperature_interne>40</temperature_interne>
	</animal>
	<animal race="reptile">
		<nom>tortue</nom>
	</animal>
	<animal race="poisson">
		<nom>saumon</nom>
	</animal>
	<animal race="poisson">
		<nom>brochet</nom>
	</animal>
</animaux>

un permier xsl, avec import

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"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:import href="sousClasses.xsl"></xsl:import>
	<xsl:template match="animaux">
		<HTML>
			<HEAD>
				<TITLE>Document Title</TITLE>
			</HEAD>
			<BODY>
				<UL>
					<xsl:apply-templates/>
				</UL>
			</BODY>
		</HTML>
	</xsl:template>
	<xsl:template match="animal">
		<LI>
			<xsl:value-of select="nom"/>
			<xsl:apply-imports></xsl:apply-imports>
		</LI>
	</xsl:template>
</xsl:stylesheet>

un deuxième xsl (sousClasse.xsl), importé par le premier

Code:

1
2
3
4
5
6
7
8
9
 
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format">
	<xsl:template match="animal[@race='mamifere']">
		<LI>
			<xsl:value-of select="temperature_interne"/>
		</LI>
	</xsl:template>
</xsl:stylesheet>

Le résultat

Code:

1
2
3
4
5
6
7
8
9
10
 
chat
36 
chien
35 
baleine
40 
tortuetortue 
saumonsaumon 
brochetbrochet

17/12/2003, 11h05
schnecke

Phil, je viens de tester ton code de départ et ça marche très bien chez moi...
Je travaille avec xmlSpy et j'ai retesté le truc avec xalan, j'obtiens dans les deux cas :

chat36
chien35
baleine40
tortue
saumon
brochet

Normalement, une seule rêgle (la plus restrictive) est appliquée.
Avec quel outil opères-tu la transfo xsl?
17/12/2003, 11h14
_gtm_
Citation:

Envoyé par schnecke

Phil, je viens de tester ton code de départ et ça marche très bien chez moi...

Si tu lis bien son post, il ne dit pas que ca marche pas, mais qu'il ne veut pas écrire deux fois
Code:

1 2 <xsl:value-of select="nom"/>
Ici, le cas est trivial, mais il on veut afficher une dixaine de champs, et qu'on a un petit paquet de classes descendantes, et qu'après il faut maintenir toutes les occurences quand la classe de base change... ben c'est pas pratique du tout.

Bonjour tout le monde,

Tout d'abord je voudrais m'excuser ne pas avoir repondu à tous ces posts (mathix, zoltar, _gtm_ et schnecke) plus rapidement. Merci de vous interesser à mes petits problèmes de conception XSL (car c'est bien de cela qu'il s'agit (et non je le repète, de trouver une solution au pb particulier d'affichage d'animaux)).

Merci à toi _gtm_ d'avoir repondu à schneke : tu as parfaitement compris mon problème : je n'aurai pas fait mieux pour la réponse.

Bon, après ce petit préambule voici une réponse pour chacun:

* _gtm_
Le problème de ta solution est qu'il n'est pas possible de redefinir completement la règle pour une race donnée mais seulement d'enrichir la règle de base (qui ici affiche le nom). Par exemple, si je veux ajouter une race "oiseau" contenant un element nom et un element "couleur bec" qui quand on l'affiche, affiche uniquement la couleur du bec (et pas le nom); ce n'est pas possible.
Cela vient du fait, que, dans ta solution, c'est la règle générale qui a le controle. Alors qu'en POO c'est la methode redefinie qui l'a : c'est elle qui peut choisir d'appeler ou non la methode heritée (via super.xxx() ou inherited()).
Je suis quand même d'accord avec toi sur un point, c'est qu'on peut faire un parallèle entre l'heritage/polymorphisme en poo et le mecanisme d'import de XSL. Cependant "import" correspond à un heritage de feuille XSL (i.e. le receveur ou cible correspond à la feuille elle-même et les méthodes correspondent aux règles. Exemple : on peut imaginer une feuille "animaux_gras.xsl" qui importe "animaux.xsl" et redefinit la template "animal" pour mettre les elements de la liste en gras (à ce moment là on a bien un appel à la méthode héritée via apply-imports)); alors que ce que je cherche à mettre en place est un heritage au niveau des elements du XML source (i.e. le receveur ou la cible correspond au contexte de mon arbre XML source).
Aussi, je ne pense pas que l'utilisation d'import soit adaptée dans ce cas là. Notamment parce qu'il y a une règle de bonne conception xsl qui dit que "si A est une feuille de style générale et B et C des feuilles spécialisées alors c'est B et C qui devraient importer A et non l'inverse" (ce qui rejoint ce que j'ai écrit plus haut sur l'heritage de XSL).

Mais ce que tu proposes est quand même ce qui s'approche le plus d'une solution à mon problème. Si tu as d'autres idées, je suis preneur.

* zoltar
Je rappelle la problématique de base : "pouvoir gérer une nouvelle race (potentiellement constitué de sous-elements et/ou d'attributs differents des autres races) sans impacter mes règles existantes mais simplement en en definissant une nouvelle". Il me semble que tes solutions ne vont pas dans ce sens (même si, j'en suis persuadé, elles sont ultra-performantes :wink: ). En plus elles n'affichent que les mamifères, alors que je veux tous les animaux (affichés différement selon leur race).

* mathix
Je t'avais promis un exemple plus parlant : le voici :
(en fait il s'agit à peu près de ce que j'essaye de faire en réalité).

L'element racine de mon doc XML est l'element "lettres". Comme tu peux t'en douter il contient des sous-elements "lettre". Chaque lettre à un attribut "type" qui peut prendre les valeurs (j'invente) "publicitaire", "professionnelle", "amicale", "delation" etc. (j'ai 18 types de lettre en tout).
Le contenu de ces elements lettres est variable (j'ai tout le temps un destinataire, souvent un expediteur, quelquefois un logo (pour les lettres pulicitaires)).
Voici un aperçu:
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 <lettres> <infos_communes_toutes_lettres> <formule_politesse>...</formule_politesse> <en-tete>...</en-tete> <formule_accuse_reception>...</formule_accuse_reception> etc, etc. </infos_communes_toutes_lettres> <lettre type="publicitaire"> <destinataire> <etat_civil> <nom>...</nom> <prenom>...</prenom> <date_naissance>...</date_naissance> .... </etat_civil> <expediteur> ... </expediteur> <logo> ... </logo> </lettre> <lettre type="professionelle"> ... </lettre> etc, etc. </lettres>
remarques :
- suivant le type de lettre les informations peuvent être affichées differement (gras, liste, tableau). Mais il arrivre souvent qu'une manière d'afficher soit commune à plusieurs types.
- tous les sous-elements d'une lettre ne sont pas forcement utilisés pour generer l'arbre destination. Cela depend du type de lettre. Par exemple, le type "delation" n'utilisera pas l'element "expediteur" (logique).
- suivant le type de lettre, le contenu de l'element "lettre" dans l'arbre source peut varier. Exemple : une lettre publicitaire contiendra un sous element "logo" mais pas une lettre "amicale".
- certaines informations proviennent d'élements exterieur à la lettre (dans l'exemple "infos_communes_toutes_lettres") dans l'arbre source. Mais doivent être intégré dans l'affichage de la lettre dans l'arbre destination. Là encore, tous les sous elements de "infos_communes" ne sont pas forcement utilisés (cela depend du type de lettre).

Et maintenant je suis sur que tu regrettes l'exemple des animaux. :wink:

CONCLUSION :
Je suppose qu'il n'y a pas de solution miracle à mon problème (xsl n'est pas java, c'est tout (et c'est tant mieux pour plein d'aspects (effets de bord, par exemple))). La solution que j'ai adopté pour mon projet est la suivante : "si la règle générale est constituée de code commun alors deporter ce code dans une autre règle ayant un mode différent". Du coup les règles générales ne contienne plus qu'un appel à une autre règle. C'est un peu lourd mais il n'y pas moyen de faire autrement (en tout cas j'ai pas trouvé). Exemple avec les animaux :
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 <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="animaux"> <HTML> <HEAD> <TITLE>Document Title</TITLE> </HEAD> <BODY> <UL> <xsl:apply-templates/> </UL> </BODY> </HTML> </xsl:template> <xsl:template match="animal"> <LI> <xsl:apply-templates select="." mode="basic"> </LI> </xsl:template> <xsl:template match="animal" mode="basic"> <xsl:value-of select="nom"/> </xsl:template> <xsl:template match="animal[@race='mamifere']"> <LI> <xsl:apply-templates select="." mode="basic"> <xsl:value-of select="temperature_interne"/> </LI> </xsl:template> </xsl:stylesheet>
Evidemment dans cet exemple, cela semble un peu ridicule, mais il faut imaginer qu'un animal contient plein de sous elements et que la règle "basic" en affiche plein (avec une mise en forme super-complexe).

Sur ce je vous salue bien, et merci encore, :ave:

Phil