Cours complet sur ATL (ATLAS Transformation Language) : l’héritage des règles

Dans l'article précédent :

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-regles-appelees-called-rules

nous avion abordé les règles appelées (Called Rules). Voyons à présent l’héritage des règles.

L’héritage des règles

Les 2 mots clés pour l’héritage des règles sont abstract et extends.

Exemple :

 abstract rule A {
      from [fromA]
      using [usingA]
      to [toA]
      do [doA]
}

rule B extends A {
      from [fromB]
      using [usingB]
      to [toB]
      do [doB]
}

 rule C extends B {
      from [fromC]
      using [usingC]
      to [toC]
      do [doC]
}

Vous auriez pu aussi écrire l’expression ci-dessous équivalente :

 rule B {
      from [fromB]
      using [usingB]
      to [toA.bindings union toB.bindings]
      do [doB]
}

 rule C {
      from [fromC]
      using [usingC]
      to [toA.bindings union toB.bindings union toC.bindings]
      do [doC]
}

ATL ne supporte pas l’héritage multiple (comme C++ par exemple) ainsi que les contraintes suivantes :

Les pattern d’entrée (partie from) des sous règles (B ou C) doivent correspondre à un sous ensemble des super règles. Par exemple si vous avez une correspondance pour une classe particulière, vous devez avoir un filtre ou une correspondance plus restrictive dans la sous classe.
Les variables des pattern d’entrée doivent avoir les même noms dans les super et sous règles
Les noms des variables des pattern de sortie doivent être les même dans les super et sous règles pour les patterns de sortie dont vous voulez l’union.

Exemple complet, tous les éléments du modèle source sont copiés tel quel dans le modèle cible :

 module Copy;
create OUT : MM from IN : MM;
rule CopyDataType extends CopyClassifier {
   from
      s : MM!DataType
   to
      t : MM!DataType
}
rule CopyEnumeration extends CopyClassifier {
   from
      s : MM!Enumeration
   to
      t : MM!Enumeration (
         literals <- s.literals
      )
}
rule CopyParameter extends CopyTypedElement {
   from
      s : MM!Parameter
   to
      t : MM!Parameter
}
rule CopyReference extends CopyStructuralFeature {
   from
      s : MM!Reference
   to
      t : MM!Reference (
         isContainer <- s.isContainer,
         opposite <- s.opposite
      )
}
rule CopyTypedElement extends CopyModelElement {
   from
      s : MM!TypedElement
   to
      t : MM!TypedElement (
         lower <- s.lower,
         upper <- s.upper,
         isOrdered <- s.isOrdered,
         isUnique <- s.isUnique,
         type <- s.type
      )
}
rule CopyOperation extends CopyTypedElement {
   from
      s : MM!Operation
   to
      t : MM!Operation (
         parameters <- s.parameters
      )
}
rule CopyAttribute extends CopyStructuralFeature {
   from
      s : MM!Attribute
   to
      t : MM!Attribute
}
rule CopyEnumLiteral extends CopyModelElement {
   from
      s : MM!EnumLiteral
   to
      t : MM!EnumLiteral
}
rule CopyPackage extends CopyModelElement {
   from
      s : MM!Package
   to
      t : MM!Package (
         contents <- s.contents
      )
}
rule CopyClass extends CopyClassifier {
   from
      s : MM!Class
   to
      t : MM!Class (
         isAbstract <- s.isAbstract,
         supertypes <- s.supertypes,
         structuralFeatures <- s.structuralFeatures,
         operations <- s.operations
      )
}
rule CopyClassifier extends CopyModelElement {
   from
      s : MM!Classifier
   to
      t : MM!Classifier
}
abstract rule CopyModelElement extends CopyLocatedElement {
   from
      s : MM!ModelElement
   to
      t : MM!ModelElement (
         name <- s.name
      )
}
rule CopyMetamodel extends CopyLocatedElement {
   from
      s : MM!Metamodel
   to
      t : MM!Metamodel (
         contents <- s.contents
      )
}
abstract rule CopyLocatedElement {
   from
      s : MM!LocatedElement
   to
      t : MM!LocatedElement (
         location <- s.location
      )
}
rule CopyStructuralFeature extends CopyTypedElement {
   from
      s : MM!StructuralFeature
   to
      t : MM!StructuralFeature (
         subsetOf <- s.subsetOf,
         derivedFrom <- s.derivedFrom
      )
}