Pour chaque déclaration de mappage du modèle de mappage, l'infrastructure de création de transformation génère une fichier source Java™ dont le nom est nTransform.java, où n représente le nom de la déclaration de mappage. Ces fichiers Java constituent collectivement le code de la transformation. En plus de la génération du code d'implémentation pour la transformation, l'infrastructure de création de transformation génère aussi du code pour enregistrer la transformation avec le service de transformation. Après avoir créé une déclaration de mappage, vous pouvez ajouter des règles de mappage de façon incrémentielle et générer le code source, ou les implémentations, pour les règles de mappage. Vous n'avez pas à définir toutes les règles de mappage avant de générer le code source.
Les déclarations de mappage suivent généralement une convention d'attribution de nom x2y, où x représente le type d'objet en entrée et y le type d'objet en sortie. Par exemple, une déclaration de mappage nommée Package2EPackage spécifie une déclaration de mappage qui a Package comme objet en entrée et EPackage comme objet en sortie.
Le mappage d'éléments établit une correspondance entre les attributs de ces éléments, ce qui permet l'échange de leurs données. La plupart des mappes permettent en outre de manipuler les données entre la source et la cible. Vous pouvez par exemple spécifier des calculs ou apporter d'autres modifications aux données en créant du code personnalisé, qui vous permet d'affecter des valeurs à la cible.
Pour créer une déclaration de mappage Classe à classe dans le modèle de mappage :
Pour ajouter un objet en entrée et un objet en sortie à la déclaration de mappage Classe à classe :


Après avoir ajouté les objets en entrée et en sortie à la déclaration de mappage, vous pouvez définir les règles de mappage entre les attributs. Les règles de mappage, également appelées mappages, spécifient comment affecter une valeur à un attribut d'un objet en sortie, en fonction des valeurs des attributs d'un objet en entrée.
Vous pouvez maintenant définir une règle de mappage entre les attributs name des objets en entrée et en sortie. La classe cible généré a le même nom que la classe du modèle en entrée ; ceci peut aussi être conçu comme étant la création d'une copie de la classe. Dans une leçon ultérieure, vous ajoutez les opérations de mappage à la règle de mappage.
Vous créez une règle de mappage de sous-mappe entre les attributs ownedOperation des objets en entrée et en sortie. Pour chaque opération de la collection ownedOperation, l'opération générée dans le modèle cible a le même nom et la même visibilité que l'opération du modèle en entrée.
Une sous-mappe est un appel d'une mappe depuis une autre mappe. La sous-mappe appelée peut (mais ne doit pas nécessairement) être définie dans le même fichier de mappage que la mappe qui l'appelle. Une sous-mappe vous permet de mapper un type complexe du modèle en entrée à un type complexe du modèle en sortie. La sous-mappe que vous créez doit appeler une mappe qui existe dans un fichier de mappage. La définition de sous-mappes dans des fichiers de mappage distincts encourage la réutilisation des mappes ; cependant, la création de plusieurs fichiers de mappage peut accroître le travail de maintenance du projet. Les sous-mappes peuvent également inclure d'autres sous-mappes, ce qui aboutit à une structure hiérarchique.
Vous pouvez aussi créer des règles de mappage de sous-mappe entre des objets en entrée et des objets en sortie dans une déclaration de mappage.
Pour chaque sous-mappe d'une déclaration de mappage, un extracteur nommé get Fonction_entréeToFonction_sortie_UsingMappe_Extractor est généré dans la transformation qui contient la déclaration, où Fonction_entrée représente le nom de l'attribut en entrée, Fonction_sortie représente le nom de l'attribut en sortie et Mappe représente le nom de la déclaration de mappage.
Vous pouvez spécifier des améliorations sémantiques à l'aide de l'API OCL (Object Constraint Language) fournie par Eclipse.
Une règle de mappage héritée, et la règle ou l'extracteur généré à partir de ce mappage, conserve la même position relative dans l'ordre de traitement que la règle de mappage remplacée et sa règle générée ou son extracteur généré.
Pour chaque déplacement ou règle de mappage personnalisée d'une déclaration de mappage, une règle est ajoutée au code source de transformation généré. Pour chaque règle de mappage de sous-mappe, un extracteur de contenu est généré dans le code source de la transformation. Lorsque vous créez une règle de mappage, son type est déterminé par les attributs en entrée et en sortie que vous sélectionnez. Par exemple, si les attributs en entrée et en sortie sont des types primitifs compatibles, tels que des chaînes ou des entiers, une règle de mappage de déplacement est spécifiée. Si les attributs en entrée et en sortie sont des types complexes, une règle de sous-mappe est spécifiée. Si ni un déplacement ni une sous-mappe ne sont des types de mappage appropriés, une règle de mappage personnalisée est spécifiée.
Pour définir les règles de mappage dans la déclaration de mappage Class2Class :
A ce stade de la leçon, dans la zone de l'éditeur, la sous-mappe a un commentaire avec un X cerclé de rouge, qui indique une erreur. Placez le pointeur de la souris sur ce commentaire pour afficher le message d'erreur. Ce message indique que vous devez sélectionner une déclaration de mappage pour la règle de mappage de sous-mappe à appeler. Pour résoudre cette erreur, créez une déclaration de mappage Opération à opération.
Pour créer une déclaration de mappage Opération à opération :