Transformaci n de modelos con atl
This presentation is the property of its rightful owner.
Sponsored Links
1 / 113

Transformación de modelos con ATL PowerPoint PPT Presentation


  • 154 Views
  • Uploaded on
  • Presentation posted in: General

Transformación de modelos con ATL. Pau Giner OO-Method Research Group Department of Information Systems and Computation Technical University of Valencia, Spain. Agenda. Introducción Lenguajes de transformación de modelos Introducción a ATL ATL y Eclipse Tutorial 1 Tutorial 2

Download Presentation

Transformación de modelos con ATL

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Transformaci n de modelos con atl

Transformación de modelos con ATL

Pau Giner

OO-Method Research Group

Department of Information Systems and Computation

Technical University of Valencia, Spain


Agenda

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


Introducci n

Introducción

  • MDD sitúa los modelos en el centro del desarrollo de software

  • Necesidad de operaciones para:

    • Mezclar {A,B}  {A+B}

    • Modificar AB

    • Relacionar AB

Transformación de modelos con ATL


Introducci n1

Modelo

Introducción

Metamodelo

¿Dónde encajan las transformaciones de modelos?

Motor de

Transformación

Reglas de

Transformación

Modelo

Metamodelo

Código

Generado

Generador de

código

Plantillas de

Generación

Transformación de modelos con ATL


Tipos de transformaciones de modelos criterios

Tipos de Transformaciones de Modelos: Criterios

  • Según metamodelos origen y destino:

    • Endógenas: el mismo metamodelo

      • Mejora de la calidad del modelo: optimización, refactorización, simplificación…

    • Exógenas: distintos metamodelos

  • Según el cambio de nivel de abstracción:

    • Síntesis: Alto  Bajo

    • Ingeniería inversa: Bajo  Alto

    • Migración: En el mismo nivel

Transformación de modelos con ATL


Tipos de transformaciones de modelos

Tipos de Transformaciones de Modelos

Model Merging

Model Modification

Model Transformation

Model Weaving/Linking

Model Marking

Transformación de modelos con ATL


Model merging

Model Merging

Varios modelos se mezclan en uno

Fácil de implementar

Los metamodelos son los mismos

Útil en modelado cooperativo

Transformación de modelos con ATL


Model modification

Model Modification

Los modelos se modifican (en tiempo de ejecución o no) para añadir elementos

Mismo metamodelo

No suele ser complejo de implementar

Transformación de modelos con ATL


Ejemplo

Ejemplo:

Eliminación de relaciones de herencia redundantes

Transformación de modelos con ATL


Ejemplo1

Ejemplo:

  • Aplicación de patrones

Transformación de modelos con ATL


Model transformation

Model Transformation

Un modelo se transforma en otro. El modelo fuente se mantiene sin cambios.

Modelos separados y metamodelos diferentes.

Transformación de modelos con ATL


Ejemplo2

Ejemplo

  • Modelo de proceso de negocio a redes de Petri para validación

Transformación de modelos con ATL


Model weaving linking

Model Weaving/Linking

Dos o más modelos se correlacionan

Los modelos originales permanecen sin modificaciones

Es necesario proporcionar un modelo de weaving

un metamodelo que defina los weavings

No soportado por la mayoría de herramientas.

Transformación de modelos con ATL


Ejemplo3

Ejemplo:

  • Trazabilidad

Transformación de modelos con ATL


Model marking

Model Marking

A veces se necesita proporcionar información específica del metamodelo destino.

Se añaden etiquetas/marcas al modelo fuente. Esto “ensucia” el modelo con conceptos específicos del modelo destino.

MDA propone añadir marcas a los modelos, pero lo soportan pocas herramientas.

Se recomienda mantener dicha información fuera del modelo (por ejemplo en ficheros XML). El motor de transformaciones ya utilizará dicha información cuando ejecute las transformaciones.

Transformación de modelos con ATL


Agenda1

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


C mo especificar transformaciones

¿Cómo especificar transformaciones?

Existen varias dimensiones mediante las cuales podemos distinguir las aproximaciones y lenguajes de transformación M2M:

Aproximación Conceptual: Procedural, Funcional, Declarativa/Relacional

Sintaxis Concreta: Textual, Gráfica

Directionalidad: Unidirectional vs. Bidireccional

Transformación de modelos con ATL


Herramientas

Herramientas

3GL contra la API del Modelo (Java+EMF/MDR)

Es complicado realizar modificaciones sencillas

XSLT

Sólo funciona con modelos basados en XML

Escalabilidad limitada. No existen operaciones sobre el metamodelo, solamente manipulan XML.

ATL: Atlas Transformation Language

Textual, usado en la práctica, con depurador

QVT: Query/Views/Transformations

Estándar de OMG. Las implementaciones están surgiendo lentamente.

MTF: Model Transformation Framework

Textual, declarativo, soportado por IBM, no es open source

oAW xTend, Kermeta

Extensiones simples para la creación d emodelos

Transformación de modelos con ATL


Alternativas principales

Alternativas principales

  • ATL: Atlas Transformation Language

    • Solución para transformaciones m2m en la comunidad Eclipse

  • MOF 2.0 QVT: Query/Views/Transformations

    • Estándar de la OMG

    • Pocas implementaciones

      • Solo de parte de la especificación

        • QVT Operational Mappings

      • Implementación OpenSource muy reciente

        • SmartQVT

Transformación de modelos con ATL


Lenguajes para la transformaci n de modelos

Lenguajes para la transformación de modelos

  • Qué aportan?

    • Primitivas cercanas al dominio (son DSLs)

    • Preservación del grafo de dependencias

    • Correspondencia entre modelos origen y destino

      • Facilidades para consultar los elementos generados por una regla

    • Son modelos

Transformación de modelos con ATL


Ejemplo4

Ejemplo

Transformación de modelos con ATL


Agenda2

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


Transformaci n de modelos con atl

ATL

Transformación de modelos con ATL

  • ATL es un subproyecto de Eclipse GMT

    • Desarrollado por el INRIA en Francia

    • requiere Eclipse como entorno de ejecución

    • Independiente del tipo de metamodelo: KM3,EMF, MDR…

  • Escalibilidad prioritaria

    • Se ejecuta en su propia máquina virtual

    • Soporte de la academia y la industria

      • Usado por Airbus, NASA Jet Propulsion Laboratory, Sodius…

    • Proporciona herramientas para su uso

  • Unidireccional

    • from  to


Transformaci n de modelos con atl

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


Tipos de fichero atl

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


Atl reglas de transformaci n

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


Patr n origen

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


Patr n destino

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


Ejemplo de regla

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


Ejemplo de regla1

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


Orden de aplicaci n de las reglas

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


Atl un vistazo a la sintaxis

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


Atl cabecera

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


Atl librer as

ATL: Librerías

uses lib_name;

  • Permiten la modularización y reutilización de helpers

    • uses string

Transformación de modelos con ATL


Atl helpers

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


Atl reglas

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


Agenda3

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


Atl y eclipse

ATL y Eclipse

  • ADT: ATL Development Tool

    • Plugin para permitir el desarrollo de transformaciones

    • Aporta editores, vistas, mecanismos de ejecución y depuración de transformaciones.

Transformación de modelos con ATL


Perspectiva editor y recursos

Perspectiva, Editor y Recursos

Transformación de modelos con ATL


Launch configuration

Launch configuration

Transformación de modelos con ATL


Depurador

Depurador

Transformación de modelos con ATL


Agenda4

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


Tutorial 1

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


Cabecera

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


Helpers

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


Reglas

Reglas

rule Book2Publication {

from b : Book!Book

to out : Publication!Publication(

title <- b.title,

nbPages <- b.getSumPages()

)

}

Transformación de modelos con ATL


Reglas con guardas

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


Mensajes de salida

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


Extras

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


Agenda5

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


Tutorial 2 liga2quiniela

Tutorial 2: Liga2Quiniela

  • Liga

    • Equipos

    • Jornadas

      • Partidos

  • Quiniela

    • Quiniela

      • Resultados [Jugados|Pendientes]

Transformación de modelos con ATL


Metamodelos

Metamodelos

Quiniela.ecore

Liga.ecore

Transformación de modelos con ATL


Mappings

Mappings

Transformación de modelos con ATL


Agenda6

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


Atl al detalle

ATL al detalle

  • Sistema de tipos

  • Comentarios

  • Expresiones declarativas

  • Helpers

  • Reglas

Transformación de modelos con ATL


Sistema de tipos

Sistema de tipos

Transformación de modelos con ATL


Ocltype

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


Oclany

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


Oclany1

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


Atl module

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


Primitive

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


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

Transformación de modelos con ATL


Collection

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


Collection1

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


Sequence

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


Transformaci n de modelos con atl

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


Iterar sobre colecciones

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


Iterar sobre colecciones1

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


Iterar sobre colecciones2

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


Enumeraciones

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”

Transformación de modelos con ATL


Tuple

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


Transformaci n de modelos con atl

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


Transformaci n de modelos con atl

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


Model elements

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


Comentarios

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


Expresiones declarativas

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


Expresiones declarativas1

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


Expresiones declarativas2

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


Funciones auxiliares

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


Helpers1

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


Helpers2

Helpers

  • Helper

    • Definición

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

      • helpercontext 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

Transformación de modelos con ATL


Helpers limitaciones

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

Transformación de modelos con ATL


Reglas atl

Reglas ATL

  • Código imperativo

  • Matched Rules

  • Called Rules

Transformación de modelos con ATL


C digo imperativo

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){…}

Transformación de modelos con ATL


Matched rules

Matched Rules

Patrón origen

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 }]

}

Variables locales

Patrón destino

Bloque imperativo

Transformación de modelos con ATL


From patr n origen

From: Patrón Origen

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

  • Ejemplo

    • from p:MM!Person

  • Puede incluir condiciones para afectar solo a un subconjunto de elementos

    • from p:MM!Person( p.name=‘Pepe’)

Transformación de modelos con ATL


Using variables locales

Using: Variables locales

  • Permite definir variables locales a usar en

    • La propia sección using

    • Secciones to y do

  • Ejemplo

    • from c:Geo!Circulousing{pi:Real=3.14area:Real=pi*c.radio.square()}

Transformación de modelos con ATL


To patr n destino

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

Transformación de modelos con ATL


Ejemplo patr n destino simple

Ejemplo: Patrón destino Simple

from b : Book!Book

to out : Publication!Publication(

title <- b.title,

nbPages <- b.getSumPages()

)

Transformación de modelos con ATL


Inicializaci n de referencias

Inicialización de referencias

  • Podemos inicializar una referencia con

    • Elemento destino creado por la propia regla

    • El elemento generado por defecto por otra regla

    • Elemento no generado por defecto de otra regla

Transformación de modelos con ATL


Inicializaci n de referencias1

Inicialización de referencias

  • 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(…)

Transformación de modelos con ATL


Inicializaci n de referencias2

Inicialización de referencias

  • Podemos inicializar una referencia con

    • El 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

    • )

  • }

Transformación de modelos con ATL


Inicializaci n de referencias3

Inicialización de referencias

  • Podemos inicializar una referencia con

    • Elemento 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)

  • }

Transformación de modelos con ATL


Patr n destino iterativo

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)

Transformación de modelos con ATL


Do bloque imperativo

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; }}

Transformación de modelos con ATL


Lazy rules

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()

Transformación de modelos con ATL


Called rules

Called Rules

  • Reglas que se llaman explicitamente

  • Sintaxis similar a las matched rules

    • No tienen sección from

    • La sección to es opcional

    • Pueden aceptar parámetros

    • Permiten definir un entrypoint

      • Se ejecutará antes de la fase de matching

Transformación de modelos con ATL


Ejemplo called rules

Ejemplo: Called Rules

helper def: schema:DB!Schema=OclUndefined

entrypoint rule Schema(){

to s:DB!Schema

do{

thisModule.schema<-s

}

}

Transformación de modelos con ATL


Agenda7

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


Tutorial 3 library2mindmap

Tutorial 3: Library2Mindmap

Transformación de modelos con ATL


Library

Library

Transformación de modelos con ATL


Mindmap

Mindmap

Transformación de modelos con ATL


Transformaci n

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

Transformación de modelos con ATL


Modelo de ejemplo

Modelo de ejemplo

Transformación de modelos con ATL


Resultado esperado

Resultado Esperado

Transformación de modelos con ATL


Transformaci n1

Transformación

Transformación de modelos con ATL


Agenda8

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


Atl avanzado

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

Transformación de modelos con ATL


M ltiples patrones origen

Múltiples patrones origen

rule StructuralFeature {

from

s : KM3!StructuralFeature,

c : KM3!Class (

c.allStructuralFeatures->includes(s)

andnot c.isAbstract

)

to

t : ATL!Binding (

propertyName <- s.name,

)

-- ...

}

Transformación de modelos con ATL


Herencia de reglas

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 {

    -- ...

    }

Transformación de modelos con ATL


Problemas comunes y soluciones

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.

Transformación de modelos con ATL


Agenda9

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


Referencias

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


  • Login