Comme je suis en train de ré-écrire toute la génération de Wikitty en
utilisant des transformeurs, je dois écrire un méta-transformeur pour
faire la tuyauterie.
Le problème que j'ai est de pouvoir exprimer quels modèles sont générés
à partir de quels autres. Il faut vraiment gérer les instances de
modèles générés de façon fine parce qu'on peut vouloir passer à deux
transformeurs différents exactement un même modèle.
Par exemple, j'ai un transformeur qui fait de la résolution de conflits,
un même modèle passé en entrée peut donner des sorties différentes (pour
peu que Eugene air passé dans le transformeurs les différents éléments
du modèle d'entrée dans des ordres différents).
Actuellement, pour décrire un méta-modèle : on fait
public WikittyMetaTransformer() {
super(WikittyContractGenerator.class,
WikittyAbstractGenerator.class,
WikittyImplementationGenerator.class,
WikittyHelperGenerator.class
);
}
C'est tout à fait suffisant quand on a que des générateurs, mais avec
les transformeurs, ça ne suffit pas.
Dans cette exemple, j'ai deux générateurs qui instancient le
transformeur de gestion de conflit, du coup, j'ai deux gestions de
conflits différentes et on risque d'aboutir à deux résolutions
différentes.
transform(Model model) {
WikittyPurifierTransformer purifier =
new WikittyPurifierTransformer();
Model purifiedModel = purifier.transform(model);
WikittyContractGenerator contractGen =
new WikittyContractGenerator();
WikittyAbstractGenerator abstractGen =
new WikittyContractGenerator();
Model contracts = contractGen.transform(purifiedModel);
Model abstracts = abstractGen.transform(purifiedModel);
// enfin, pour générer le Java un truc du genre
ObjectModelToJava toJava = new ObjectModelToJava(destDir);
toJava.transform(contracts);
toJava.transform(abstracts);
}
Quelque chose du genre permet de chaîner les transformeurs comme on veut
et de répondre à l'essentiel des besoins.
On pourrait également imaginer les choses suivantes, afin de faire de la
transformation à partir du texte généré (XML ?) et chaîner les
méta-transformers
toJava.transform(contracts) par exemple retourne une
List<GeneratedFile>, les éléments de ces listes permettent d'accéder au
nom du fichier générer, au contenu. Éventuellement, on pourrait ne pas
spécifier de destDir à la construction et récupérer les GeneratedFile
pour les écrire soi-même et les envoyer vers un reader. Ainsi un peu
chaîner des transformeurs, et dans des situations exceptionnelles faire
passer le chaînage par du texte, par exemple, pour réutiliser un
métatransformer qui attend un objectmodel en sortie, je peux sortir un
objectmodel et chaîner les méta-transformeurs
Réflexions et commentaires bienvenus, je crois que c'est en gros ce
qu'on a déjà dit avec Tony mais ce serait bien que d'autres se
prononcent vu qu'il s'agit quand même d'un aspect important de Eugene en
général et des transformeurs, en particulier.
