Transformación de modelos con ATL

1. Transformación de modelos con ATL Pau Giner OO-Method Research Group Department of Information Systems and Computation Technical University of Valencia, Spain

2. 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 Transformación de modelos con ATL

3. 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 Transformación de modelos con ATL

4. Tipos de fichero ATL • ATL module • Conjunto de reglas de transformación • Library • Conjunto de funciones de ayuda que puede ser importado • Query • Consultas que obtienen un valor simple de un modelo Transformación de modelos con ATL

5. 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. Transformación de modelos con ATL

6. Patrón Origen • El patrón origen está formado por: • Un conjunto etiquetado de elementos de los metamodelos origen • Una 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. Transformación de modelos con ATL

7. 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 Transformación de modelos con ATL

8. Tabla Clase nombre nombre persistente Ejemplo de regla • “Las Clases marcadas como persistentes, se transformarán en Tablas cuyo nombre será el nombre de la clase original” Transformación de modelos con ATL

9. Tabla Clase nombre nombre persistente 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 Transformación de modelos con ATL

10. 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 Transformación de modelos con ATL

11. ATL: Un vistazo a la sintaxis • Transformación (ATL module): • Cabecera • Importación de librerías • Helpers y Attributes • Reglas • Modos de ejecución • Normal • Refinamiento Transformación de modelos con ATL

12. 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 Transformación de modelos con ATL

13. ATL: Librerías uses lib_name; • Permiten la modularización y reutilización de helpers • uses string Transformación de modelos con ATL

14. ATL: Helpers helper [context context_type] def : helper_name(parameters) : return_type = exp; • Permiten extender el metamodelo con funciones y atributos derivados • Son atributos si no se usan parámetros • Las expresiones se definen en OCL • El contexto es opcional • El modulo ATL es el contexto por defecto • Ej: helpercontext Liga!Partido def: nombre : String = self.local.nombre +' - '+self.visitante.nombre; Transformación de modelos con ATL

15. 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 }] } Transformación de modelos con ATL

16. 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 Transformación de modelos con ATL

17. 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. Transformación de modelos con ATL

18. Cabecera moduleBook2Publication; createOUT : PublicationfromIN : Book; • Los elementos create y from definen los modelos de salida y entrada que se representan mediante las variables OUT e IN Transformación de modelos con ATL

19. 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 helpercontext 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 Transformación de modelos con ATL

20. Reglas rule Book2Publication { from b : Book!Book to out : Publication!Publication( title <- b.title, nbPages <- b.getSumPages() ) } Transformación de modelos con ATL

21. 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() ) } Transformación de modelos con ATL

22. Mensajes de salida • Todo elemento tiene la operación debug que • Devolverá 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 Transformación de modelos con ATL

23. 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 Transformación de modelos con ATL

24. 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 Transformación de modelos con ATL

25. ATL al detalle • Sistema de tipos • Comentarios • Expresiones declarativas • Helpers • Reglas Transformación de modelos con ATL

26. Sistema de tipos Transformación de modelos con ATL

27. 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’) Transformación de modelos con ATL

28. 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) Transformación de modelos con ATL

29. 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 Transformación de modelos con ATL

30. 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 Transformación de modelos con ATL

31. 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 Transformación de modelos con ATL

32. 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 Transformación de modelos con ATL

33. 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() Transformación de modelos con ATL

34. 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() Transformación de modelos con ATL

35. 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 Transformación de modelos con ATL

36. 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 Transformación de modelos con ATL

37. 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 Transformación de modelos con ATL

38. Iterar sobre colecciones • 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 Transformación de modelos con ATL

39. Iterar sobre colecciones • Para casos más complejos… • Iterate(iterador; variable=inicialización | cuerpo) • Ejemplo • Set{1,2,3}->iterate(e; res:Integer=0 | res+e) Transformación de modelos con ATL

40. 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 Transformación de modelos con ATL

41. Tuple • Permiten definir valores compuestos • Definición • TupleType(var_name, var_type,…) • Ej.: TupleType(a:MM!Author, title:String) • Uso • Tuple{var_name[:var_type]=value,…} • Ej.:Tuple{title=‘El Aleph’, author=b} Transformación de modelos con ATL

42. Map • Define una tabla de mappings clave-valor • Definición • Map(key_type, value_type) • Ej.: Map(Integer, MM!Author) • Uso • Map{(key,value),…} • Ej.: Map{(1,aut1), (2,aut2)} Transformación de modelos con ATL

43. 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 Transformación de modelos con ATL

44. 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 * Transformación de modelos con ATL

45. Comentarios • Se usa el doble guión • Ejemplo: --comentario • Hasta el final de la línea • En la primera línea del fichero, determinan el compilador • -- @atlcompiler atl2006 • -- @atlcompiler atl2004 Transformación de modelos con ATL

46. Expresiones declarativas • If • Permite definir expresiones condicionales • ifcondiciónthenexp1elseexp2endif • No se puede omitir ninguna parte • Representa decisiones sobre datos • No control de flujo • Ej: if x>3 then ‘mayor que 3’ else ‘menor o igual que 3’ endif Transformación de modelos con ATL

47. Expresiones declarativas • Let • Permite definir variables locales • letnombre:tipo=inicializacióninexp • 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 Transformación de modelos con ATL

48. Expresiones declarativas • 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 Transformación de modelos con ATL

49. 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 Transformación de modelos con ATL

50. Helpers • Helper • helper [context context_type] def : helper_name(parameters) : return_type = exp; • Attribute • helper [context context_type] def : helper_name : return_type = exp; Transformación de modelos con ATL