Héritage et polymorphisme

Les templates sont définis sur une métaclasse particulière dans un fichier de définition de langage ou dans une extension et sont hérités par et disponibles pour les enfants de cette métaclasse. Par exemple, un template défini sur la métaclasse Classifier est disponible pour les templates ou fichiers générés définis sur les métaclasses Class et Interface.

GTL prend en charge les concepts orientés objet suivants comme faisant partie de l'héritage :

Polymorphisme - Le choix du template à évaluer est effectué au moment de la conversion. Un template défini sur un classificateur peut accéder aux templates définis sur ses enfants (classe, interface). Dans l'exemple suivante, le contenu de %definition% dépend de l'objet (classe ou interface) en cours de traitement :
Redéfinition de template - Un template défini sur une métaclasse particulière peut être redéfini par un template de même nom défini sur une classe enfant. Dans l'exemple suivant, le template défini sur la métaclasse Classifier est redéfini par celui défini sur la métaclasse Class :

Vous pouvez afficher le parent redéfini en pointant sur le template enfant, cliquant le bouton droit de la souris, puis sélectionnant Afficher la super-définition. Vous pouvez spécifier l'utilisation du template parent en préfixant l'appel de template de l'opérateur qualifiant ::. Par exemple : %Classifier::isAbstract%.
Surcharge de template - Vous pouvez surcharger vos définitions de templates et tester pour différentes conditions. Les templates peuvent également être définis sous des critères (voir Critères (Profile)) ou des stéréotypes (voir Stéréotypes (Profile)), et les conditions correspondantes sont combinées. Au moment de la conversion, chaque condition est évaluée et le template approprié (ou, en l'absence de correspondance, le template par défaut) est appliqué. Par exemple :

Vous pouvez définir le même template plusieurs fois dans la hiérarchie de fichiers de définition de langage ou d'extension, et PowerAMC le résoudra en utilisant des règles d'héritage. Par exemple, le fichier de définitions de langage de MOO monLang et le fichier d'extension monExtension contiennent chacun un template %t% défini sur chacune des métaclasses Classifier et Class :

Fichier de définition de langage monLang	Fichier d'extension monExtension
Classifier : fichier généré `monFichier` template `%t%` template Class : `%t%` template	Classifier : fichier généré `monAutreFichier` template `%t%` Class : `%t%` template

Les métaclasses Class et Interface héritent toutes deux de la métaclasse Classifier, et génèrent chacune un monFichier et un monAutreFichier.

Les appels de template suivants sont possibles dans monLang/Classifier/monFichier (qui ne peut pas accéder aux templates contenus dans monExtension) :

Appel de template dans monFichier	Template appelé
`%t%` or `%monLang::t%`	`monLang/Class/t`
`%Classifier::t%` or `%monLang::Classifier::t%`	`monLang/Classifier/t`

Appel de template dans monFichier

Template appelé

%t% or

%monLang::t%

monLang/Class/t

%Classifier::t% or

%monLang::Classifier::t%

monLang/Classifier/t

Les appels de template suivants sont possibles dans myExtension/Classifier/monAutreFichier (qui peut accéder à la fois à ses propres templates et à ceux contenus dans monLang) :

Appel de template dans monAutreFichier	Template appelé
`%t%` or `%myExtension::t%`	`myExtension/Class/t`
`%Classifier::t%` or `%myExtension::Classifier::t%`	`myExtension/Classifier/t`
`%monLang::t%` or `%monLang::Class::t%`	`monLang/Class/t`
`%monLang::Classifier::t%`	`monLang/Classifier/t`

Remarque : Pour qu'un fichier d'extension puisse atteindre des templates définis dans un fichier de définition de langage, la propriété Compléter la génération de langage doit être sélectionnée dans l'extension (voir Propriétés d'un fichier d'extension).