Transformación de modelos con ATL

Transformación de modelos con ATL

Pau GinerPau Giner

OO-Method Research GroupDepartment of Information Systems and Computation

Technical University of Valencia, Spain

Transformación de modelos con ATL 2/113

Agenda Introducción Lenguajes de transformación de modelos Introducción a ATL ATL y Eclipse Tutorial 1 Tutorial 2 ATL al detalle Tutorial 3 ATL Avanzado Referencias


ATL

Diferencias entre modelos origen y destino Los modelos origen solo se pueden leer Los modelos destino solo pueden ser escritos

Lenguaje híbrido: Imperativo-Declarativo Declarativo

Matched rules basadas en pattern-matching Lenguaje de navegación sin efectos laterales (OCL-like)

Imperativo Called rules Action blocks


Tipos de fichero ATL

ATL moduleConjunto de reglas de transformación

LibraryConjunto de funciones de ayuda que puede ser

importado Query

Consultas que obtienen un valor simple de un modelo


ATL: Reglas de transformación

Una regla declarativa especifica: Un patrón origen que se buscará en los modelos fuente, Un patrón destino que se creará en el destino por cada regla que haga

matching. Una regla imperativa es un procedimiento:

Se llama explícitamente Puede tomar argumentos Puede contener:

Un patrón declarativo, Un action block (secuencia de sentencias), Ambos.


Patrón Origen

El patrón origen está formado por:Un conjunto etiquetado de elementos de los

metamodelos origenUna guarda

Expresión booleana a modo de filtro Se producirá un matching si se encuentran

elementos en los modelos origen que:Sean de los tipos especificados en el patrón,Satisfagan la guarda.


Patrón Destino

El patrón destino está compuesto de: Elementos etiquetados del metamodelo destino Para cada elemento una inicialización de sus propiedades

Para cada coincidencia se aplica el patrón destino: Se crean los elementos destino Se inicializan sus propiedades

Primero, evaluando el valor de las expresiones Después, asignando dicho valor a la propiedad indicada


Ejemplo de regla

“Las Clases marcadas como persistentes, se transformarán en Tablas cuyo nombre será el nombre de la clase original”

Clase

nombrepersistente

Tabla

nombre


Ejemplo de regla

Metamodelos Origen: Diagrama de Clases Destino: Modelo Relacional

Patrón origen Elementos

c: Clase Guarda

c.persistente Patrón destino

Elementos t:Tabla

Inicialización t.nombre c.nombre

Clase

nombrepersistente

Tabla

nombre


Orden de aplicación de las reglas

Con las reglas declarativas permiten al desarrollador despreocuparse del orden de ejecución: No se especifica el orden de

Aplicación de reglas Inicialización de propiedades

Sin embargo, se mantiene el determinismo La ejecución de una regla no puede cambiar el modelo

origen No puede alterar las coincidencias

El modelo destino no es navegable La creación de un elemento no puede afectar el valor de otro


ATL: Un vistazo a la sintaxis

Transformación (ATL module):Cabecera Importación de libreríasHelpers y AttributesReglas

Modos de ejecuciónNormalRefinamiento


ATL: Cabecera

module module_name;

create output_models [from|refines] input_models; Se especifica:

Nombre del modulo Modelos y Metamodelos implicados

OUT1 : UML, OUT2 : TraceModel… Tipo de transformación

Modelo nuevo Refinamiento

En versiones recientes la palabra clave es refining


ATL: Librerías

uses lib_name;

Permiten la modularización y reutilización de helpersuses string


ATL: Helpers

helper [context context_type] def : helper_name(parameters) :

return_type = exp; Permiten extender el metamodelo con funciones y

atributos derivadosSon atributos si no se usan parámetrosLas expresiones se definen en OCLEl contexto es opcional

El modulo ATL es el contexto por defecto Ej: helper context Liga!Partido def: nombre : String =

self.local.nombre +' - '+self.visitante.nombre;


ATL: Reglas

rule rule_name {from in_var : in_type [(condition)]

[using {var1 : var_type1 = init_exp1; ... varn : var_typen = init_expn;}]

to out_var1 : out_type1 ( bindings1 ) ... out_varn : out_typen ( bindingsn )

[do { statements }]}


Tutorial 1

Metamodelos Entrada: Book Salida: Publication

Modelo de entrada: libro.xmi

Transformación: Crear para cada Libro una Publicación cuyo

atributo nbPages sea la suma de las páginas de los capítulos del libro.


Cabecera

module Book2Publication;

create OUT : Publication from IN : Book;

Los elementos create y from definen los modelos de salida y entrada que se representan mediante las variables OUT e IN


Helpers

Definimos un helper getSumPages que nos devuelva el número de páginas de un libro Sumando las páginas de cada capítulo

helper context Book!Book def : getSumPages() : Integer =

self.chapters->collect(c|c.nbPages).sum(); Los contextos se expresan como Metamodelo!

Elemento Book!Book: La clase Book del metamodelo Book


Reglas

rule Book2Publication {from b : Book!Bookto out : Publication!Publication( title <- b.title, nbPages <- b.getSumPages())}


Reglas (con Guardas)

Si añadimos el requisito de que solo se transformen los libros con más de dos páginas

rule Book2Publication {from b : Book!Book ( b.getSumPages() > 2) to out : Publication!Publication ( title <- b.title, nbPages <- b.getSumPages() )}


Mensajes de salida

Todo elemento tiene la operación debug queDevolverá el propio elemento

Por lo que no afectará a la computación

Mostrará un mensaje por la consola Permitirá obtener mensajes de ayuda para el

desarrollador

Ej: b.getSumPages().debug(‘paginas’) > 2


Extras

Depuración La perspectiva de depuración permite ejecutar paso a

paso las reglas Queries

Permiten calcular valores primitivos a partir de elementos del modelo.

Ejemplo query caps = Book!Chapter.allInstances()->size().toString(); El método writeTo(fichero:String) permite escribir la cadena a un

fichero


ATL al detalle

Sistema de tipos Comentarios Expresiones declarativas Helpers Reglas


Sistema de tipos


OclType

Sus instancias son los distintos tipos Operaciones

allInstances() Devuelve el conjunto de las instancias de un tipo

Book!Chapter.allInstances()

allInstancesFrom(metamodel:String) Devuelve las instancias contenidas en el modelo

Book!Chapter.allInstancesFrom(‘IN’)


OclAny

Cualquier objeto pertenece a OclAny Operaciones

Comparación: = <> oclIsUndefined

Indica sí self no está definido (análogo al null) oclIsKindOf(t: oclType)

Indica si self es instancia directa o indirecta del tipo t 3.oclIsKindOf(OclAny)

oclIsTypeOf(t:oclType) Indica si self es instancia directa del tipo t

3. oclIsTypeOf(Integer)


OclAny

Operaciones toString()

Versión textual del objeto

oclType() Tipo del objeto

asSequence(), asSet(), asBag() Convierte el objeto en secuencia, conjunto y bolsa

refImmediateComposite Obtiene el objeto bajo el cual self está compuesto


ATL Module

Representa el módulo y solo tiene una instancia: thisModule

Permite definir helpers y atributos “globales” Operaciones

resolveTemp(var:oclAny, target:String) Permite determinar que patrón target se aplicará a un

objeto origen var. Útil cuando no se desea aplicar el patrón por defecto


Primitive

Tipos primitivos Boolean: true, false

Operadores lógicos: and, or, xor, not implies(b:Boolean): self b

Numerical (Integer, Real) Comparación: <, >, =>, >= Operadores: *, +, -, /, div(x), max(x), min(x), abs() Particulares: mod(x) para Integer y floor y round para Real Aritméticas: cos, sin, toDegrees, toRadians, exp, log, sqrt…

String


String

Se define usando comillas simples Ej.: ‘ejemplo de cadena de carácteres’ Se indexa comenzando por el 1 Operaciones

size() concat(s: String)

Alternativamente puede usarse el operador + substring(lower:Integer, upper:Integer) Conversión: toInteger, toReal, toSequence, toUpper, toLower Salida

writeTo(file:String): escribe la cadena a un fichero Las rutas relativas se consideran desde el directorio de eclipse

println(): escribe en la salida estándar


Collection

Es un tipo abstracto que engloba a los 4 tipos de colecciones: Set: conjunto

Sin duplicados y sin orden OrderedSet

Sin duplicados y con orden Bag

Con duplicados y sin orden Sequence

Con duplicados y con orden Definición: tipo_colección(tipo_elementos)

Set(Integer) Instanciación: tipo_colección{elementos}

Set{1,2,3} La invocación de operaciones se realiza utilizando ‘->’

'Set{1,2,3}->size()


Collection

Operaciones comunes size() includes(x:oclAny)

Devuelve true si x pertenece a la colección. excludes(x:oclAny)

Devuelve true si x no pertenece a la colección. count(x:oclAny)

Nº de veces que aparece x en la colección includesAll(c: Collection)

Devuelve true si todos los objetos de c pertenecen a la colección excludesAll(c: Collection)

Devuelve true si ninguno de los objetos de c pertenecen a la colección isEmpty(), notEmpty() sum()

Aplica el operador + a todos los elementos de la colección asBag(), asSequence(), asSet()


Sequence

union(c: Colection) Devuelve una colección con la unión de los contenidos

flatten() Sequence{Set{1,2},Set{3,4}} Sequence{1,2,3,4}

append, prepend, insertAt(pos:Integer) Inserción al final, inicio o posición determinada

first(), last(), at(pos:Integer) Recuperación del primer, último o elemento indicado


Set

union, intersection self –(s:Set)

Set con los elementos de self que no están en s

Including(x:oclAny), excluding(x:oclAny) Devuelven un set con o sin el elemento x

symetricDifference(s:Set) Devuelve los elementos que están en self o en s pero no

en ambos


Iterar sobre colecciones

Facilidades para recorrer colecciones Colección->operación(iteradores| cuerpo)

Operaciones exists

Devuelve true si se cumple el cuerpo para algún elemento forAll

Devuelve true si se cumple el cuerpo para todos los elementos one

Devuelve true si se cumple el cuerpo para un único elemento isUnique

Devuelve true si el cuerpo se evalúa a un valor distinto para cada elemento



Operaciones any

Devuelve un elemento que satisface el cuerpo, o el valor OclUndfined collect

Devuelve una colección de elementos resultantes de aplicar el cuerpo a cada uno de los elementos

select Devuelve el conjunto de elementos que satisfacen el cuerpo

reject Devuelve el conjunto de elementos que no satisfacen el cuerpo

sortedBy Devuelve una colección ordenada según el criterio establecido en el

cuerpo



Para casos más complejos… Iterate(iterador; variable=inicialización | cuerpo)

EjemploSet{1,2,3}->iterate(e; res:Integer=0 | res+e)


Enumeraciones

Para acceder a los literales de una enumeración se utiliza el carácter #El tipo de numeración es inferido por el sistema

Ej.: dia<- #Lunes

Si el nombre del literal coincide con alguna palabra reservada, se entrecomillará

Ej: #”Integer”

Para comparar mp.kind <> #out


Tuple

Permiten definir valores compuestos Definición

TupleType(var_name, var_type,…)Ej.: TupleType(a:MM!Author, title:String)

UsoTuple{var_name[:var_type]=value,…}Ej.:Tuple{title=‘El Aleph’, author=b}


Map

Define una tabla de mappings clave-valor Definición

Map(key_type, value_type)Ej.: Map(Integer, MM!Author)

UsoMap{(key,value),…}Ej.: Map{(1,aut1), (2,aut2)}


Map

Operaciones get(key) value including(key,val)

Nuevo Map, que incluye el valor indicado si no contenía la clave key

Union(m:Map) Nuevo Map, que incluye los elementos de m

getKeys, getValues Colección con las claves o los valores


Model Elements

Los elementos definidos en los metamodelos se consideran nuevos tipos de ATL

Los tipos se referencian a partir de su metamodelo Metamodel!class Ej: Library!Author

Navegación por punto Tanto para recorrer atributos como referencias

Ej.: aut1.nombre Test de vacío

oclIsUndefined() para atributos con cardinalidad 0..1 isEmpty() para atributos con cardinalidad *


Comentarios

Se usa el doble guiónEjemplo: --comentario

Hasta el final de la línea En la primera línea del fichero, determinan el

compilador-- @atlcompiler atl2006 -- @atlcompiler atl2004


Expresiones declarativas

IfPermite definir expresiones condicionales if condición then exp1 else exp2 endif

No se puede omitir ninguna parteRepresenta decisiones sobre datos

No control de flujoEj: if x>3 then ‘mayor que 3’ else ‘menor o igual

que 3’ endif



Let Permite definir variables locales let nombre : tipo = inicialización in exp let a: Integer = 1 in a+2 Se pueden encadenar

let a:Integer=1 inlet b:Integer=2 ina+b

Facilitan la legibilidad y la depuración



Cuidado!! Las expresiones lógicas se evalúan completamente Problema

not person.oclIsUndefined() and person.name=‘Pepe’ El acceso a name se realizará independientemente de que person

esté definida o no. Produciendo el consecuente error en caso de no estarlo

Suele darse en el cuerpo de los iteradores Solución

if person.oclIsUndefined() then false else person.name=‘Pepe’ endif


Funciones auxiliares

Permiten factorizar el código Se definen en base a un contexto

Tipo de elementos sobre el que se puede aplicar El contexto por defecto es el módulo

Se invocará el helper a partir de la variable thisModule Puede haber varios helpers con el mismo nombre

En contextos distintos Existen dos tipos

Helpers Aceptan parámetros

Attributes No aceptan parámetros Más eficientes


Helpers

Helper helper [context context_type] def : helper_name(parameters) :

return_type = exp; Attribute

helper [context context_type] def : helper_name : return_type = exp;


Helpers

Helper Definición

helper [context context_type] def : helper_name(parameters) : return_type = exp;

helper context Integer def: suma(b:Integer):Integer= self*b; Uso: 3.suma(2)

Attribute Definición

Como el helper pero sin parámetros helper context MM!Person def: mayor: Boolean= self.age>=18

Uso: p.mayor


Helpers: Limitaciones

No se puede definir una colección como contexto Problema

helper context Set(MM!Person) def: getYounger(age:Integer): Set(MM!Person)…

Solución helper def getYpunger(s: Set(MM!Person, age:Integer)…

En las librerías no se aceptan attributes Se debe definir toda función como helper


Reglas ATL

Código imperativo Matched Rules Called Rules


Código Imperativo

Se puede especificar código imperativo en Bloques imperativos Reglas (matched o called)

Bloque imperativo Conjunto de sentencias imperativas separadas por ;

Tipo de sentencia Asignación

Target <- exp; Condición

if(condición) { sentencias;} [else {sentencias;}]? Bucles

for(iterador in colección) { sentencias;} for(p in persons){…}


Matched Rules

rule rule_name {from in_var : in_type [(condition)]

[using {var1 : var_type1 = init_exp1; ... varn : var_typen = init_expn;}]

to out_var1 : out_type1 ( bindings1 ) ... out_varn : out_typen ( bindingsn )

[do { statements }]}

Patrón origen

Variables locales

Patrón destino

Bloque imperativo


From: Patrón Origen

Determina los elementos origen sobre los que se aplicará la regla

Ejemplofrom p:MM!Person

Puede incluir condiciones para afectar solo a un subconjunto de elementosfrom p:MM!Person( p.name=‘Pepe’)


Using: Variables locales

Permite definir variables locales a usar en La propia sección using Secciones to y do

Ejemplo from c:Geo!Circulo

using{pi:Real=3.14area:Real=pi*c.radio.square()

}


To: Patrón destino

La sección to contiene un conjunto de patrones de destino El primero se considerará el patrón por defecto Los patrones se definen

Indicando un elemento de destino Especificando su inicialización

Hay dos tipos de patrones destino Simple

Genera un elemento destino por regla Iterativo

Genera un conjunto de elementos por regla


Ejemplo: Patrón destino Simple

from b : Book!Book

to out : Publication!Publication(

title <- b.title,

nbPages <- b.getSumPages()

)


Inicialización de referencias

Podemos inicializar una referencia conElemento destino creado por la propia reglaEl elemento generado por defecto por otra reglaElemento no generado por defecto de otra regla



Podemos inicializar una referencia con Elemento destino creado por la propia regla

from c:UML!Classto tabla:DB!Table( name <- c.name, primaryKey <- pk)pk:DB!PrimaryKey(

…)



Podemos inicializar una referencia conEl elemento generado por defecto por otra regla

rule model2schema{from m:UML!Modelto s:DB!Schema( name <- m.name, tables<- m.classes)}

rule class2table{ from c: UML!Class to tabla: DB!Table(

name <- c.name)

}



Podemos inicializar una referencia conElemento no generado por defecto de otra regla

rule model2schema{from m:UML!Modelto s:DB!Schema( name <- m.name, tables<- m.classes-> collect(c|thisModuleResolveTemp(c,’tabla’))}

rule class2table{ from c: UML!Class to o: DB!Otro( … ), tabla: DB!Table(

name <- c.name)}


Patrón destino Iterativo

Permite generar un conjunto de elementos destino a partir de un elemento orígen

Definición: distinct tipo foreach(iterador)

Ejemplo using{ nombres: Sequence(String)=Sequence{‘a’,’b’,’c’}}

to tablas: distinct DB!Table foreach(e in nombres)(

name <- e)


Do: Bloque Imperativo

Las matched rules permiten incluir opcionalmente bloques imperativos

Ejemplo helper def id: Integer=0;

… rule class2table{

from c:UML!Classto t:DB!Table(…)do{ thisModule.id <- thisModule.id+1; t.id <-thisModule.id; }}


Lazy rules

Variante de las matched rules Reglas declarativas que deben ser llamadas

explicitamente En cada llamada generan elementos nuevos

Salvo que se definan como unique lazy rule Ejemplo

Definición lazy rule getTable {

from i: UML!Class to rel: DB!Table ( ) } Llamada:

thisModule.getTable()


Called Rules

Reglas que se llaman explicitamente Sintaxis similar a las matched rules

No tienen sección fromLa sección to es opcionalPueden aceptar parámetrosPermiten definir un entrypoint

Se ejecutará antes de la fase de matching


Ejemplo: Called Rules

helper def: schema:DB!Schema=OclUndefined

…

entrypoint rule Schema(){

to s:DB!Schema

do{

thisModule.schema<-s

}

}


Tutorial 3: Library2Mindmap


Library


Mindmap


Transformación

Los Autores y Empleados se presentarán como Topics Los topics de Autor con prioridad 5 Los topics de Empleado con prioridad 0

Habrá relaciones de tipo Dependency entre topics sii El topic origen es un autor y el destino un empleado El empleado está encargado de alguna estantería dónde se encuentra

algún libro del autor Los topics de autores contendrán un Thread por libro

Cada Thread contendrá un ThreadItem con el nombre de la estantería que contiene el libro

Los Topics de Empleados contendrán un Thread por cada estantería de la que se encargan


Modelo de ejemplo


Resultado Esperado


Transformación


ATL Avanzado

ATL 2006 Nuevo compilador (frente a ATL 2004) Introduce diversas mejoras

Múltiples patrones Origen Herencia de reglas

Para usarlo el módulo debe contener en la primera línea el comentario:

-- @atlcompiler atl2006

No soporta (todavía) el modo de ejecución de refinamiento


Múltiples patrones origen

rule StructuralFeature {from

s : KM3!StructuralFeature,c : KM3!Class (

c.allStructuralFeatures->includes(s)and not c.isAbstract

)to

t : ATL!Binding (propertyName <- s.name,

)-- ...

}


Herencia de reglas

Las reglas hijas deben afectar a un subconjunto de los elementos de la regla padre

abstract rule R1 {-- ...

}rule R2 extends R1 {-- ...

}


Problemas comunes (y soluciones!)

Si algún literal o nombre de elemento coincide con alguna palabra reservada, deberá entrecomillarse #”1”, “Map”…

No puede haber dos reglas con el mismo nombre Solo puede haber una regla por elemento del metamodelo origen.

Se pueden definir varios objetivos alternativos, pero para que se ejecuten deberá indicarse explícitamente mediante resolveTemp.

resolveTemp no se puede ejecutar sobre colecciones Hay que usar collect para aplicarlo a los elementos

Cuando hay varios modelos de salida si son del mismo metamodelo no hay forma de determinar en cual de los dos queremos crear elementos ya que solo se indican los elementos a crear de la forma MM!Elemento. Solución: definirlos como si fuesen de metamodelos distintos y en la

configuración indicar que se trata del mismo.


Referencias

ATL Documentation User Manual, Starter Guide… http://www.eclipse.org/m2m/atl/doc/

Open Model CourseWare http://www.eclipse.org/gmt/omcw/resources/chapter10/

Ejemplos (unos 100) ATL Transformations

http://www.eclipse.org/m2m/atl/atlTransformations/ ATL Use Cases

http://www.eclipse.org/m2m/atl/usecases/ Problemas y soluciones

http://wiki.eclipse.org/index.php/ATL_Language_Troubleshooter

Transformación de modelos con ATL

Documents

Transcript of Transformación de modelos con ATL