Model Transformations "Rien ne se perd, rien ne se crée, tout se transforme." Antoine-Laurent de...

ModelModel TransformationsTransformations"Rien ne se perd, rien ne se crée, tout se transforme.""Rien ne se perd, rien ne se crée, tout se transforme."

Antoine-Laurent de Lavoisier (1743-1794)Antoine-Laurent de Lavoisier (1743-1794)

Marcellus TavaresRicardo Roberto de Lima

OutlineOutline

What is model General idea of model transformations Classification of model transformations Transformation techniques Comparison Conclusion References

Raising the level of abstractionRaising the level of abstraction

An Introduction to Model An Introduction to Model TransformationsTransformations

Model as key artifact of MDA Model transformations as central operation Model transformations are also modeled

The Model-Driven ArchitectureThe Model-Driven Architecture

Metamodel is defined by its metametamodel Metametamodel introduce semantics required to specify

metamodels Metametamodel is self defined

Its specified in term of its own semantics MOF e Ecore

The Model-Driven ArchitectureThe Model-Driven Architecture

Model TransformationsModel Transformations

Specify the way to produce target models from a number source models

Developers define the way source model elements must be matched and navigated in order to initialize the target models

A model transformation is a mapping of a set of models onto another set of models or onto themselves, where a mapping defines correspondences between elements in the source and target models

Caplat and Sourrouille

Model TransformationModel Transformation

ModelTransformation

Engine

ModelTransformation

Meta-model

ModelTransformations

PSMMeta-model

PIMMeta-model

MOF Meta-Meta-model

Model Transformation OntologyModel Transformation Ontology

Model Transformation

MonolithicTransformation

CompositionalTransformation

complete, disjoint

VerticalTransformation

HorizontalTransformation

complete, disjoint

EndogenousTransformation

ExogenousTransformation

complete, disjoint

DeclarativeTransformation

ImperativeTransformation

complete, disjoint

ViatraGReATOptimalJ

ForaQVTATL

Generalpurpose programming language

JETAndroMDA

QVTATL

MMa=MMb Mma!=MMb

Model Transformation OntologyModel Transformation Ontology

Vertical High-level to low-level representation Model refinement PIM to PSM

Horizontal Does not preserve source model structure Endogen transformation Refactoring, Update

Transformations categoriesTransformations categories

Model-to-codeVisitor-Based

Visitor mechanism to transverse model and write code

Jamda (OO FW providing set of classes to represent UML Models and a visitor mechanism “code writers”)

Template-basedJET, AndroMDA, OptimalJ

Model-to-modelTranslate between source and target modelsMost existing MDA tools do not provide

Direct-Manipulation Approach (imperative)Internal model representation + APIOO frameworkTransformations rules implemented from

scratch Java

Relational approach (declarative)Source and target as a relationLogic programming (predicates used to

describe relations)Flora

Hybrid approachCombine different techniques QVT, ATL

OthersXSLT

Desirable properties of a transformation Desirable properties of a transformation languagelanguage

Be executable; Be implementable in an efficient way; Be fully expressive, yet unambiguous. Facilitate developer productivity with precise,

concise and clear descriptions: Provide a means to combine transformations to form

composite ones [reuse] Provide a means to define scheduling Defined upon a Metamodel

General purpose General purpose programming languagesprogramming languages

Java, C++, C# Available via APIs,

however rules are implemented from scratch Advantage: No overhead to learn a new language Example: Java + EMF SDK

Book To Publication considering the Book To Publication considering the UML 2.0 metamodelUML 2.0 metamodel

Example Java + EMF SDKExample Java + EMF SDK

Metamodel using Ecore API provided by EMF Code Generation Model exported to XMI myBook.xmi

<?xml version="1.0" encoding="ASCII"?><xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:book="http://book.ecore"> <book:Book title=“Java"/> <book:Chapter numPages=“10" title="Basic" author="Deitel"/> <book:Chapter numPages=“15" title="Advanced" author="Jose"/></xmi:XMI>

public class JavaTransformation {

public static void main(String[] args) { // Create a resource set. ResourceSet resourceSet = new ResourceSetImpl();

// Register the default resource factory resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put( Resource.Factory.Registry.DEFAULT_EXTENSION, new XMIResourceFactoryImpl()); // Register the package -- only needed for stand-alone! BookPackage bookPackage = BookPackage.eINSTANCE; // Source model URI fileURI = URI.createFileURI(new File("mybook.xmi").getAbsolutePath()); // Get the resource Resource resource = resourceSet.getResource(fileURI, true); TreeIterator<EObject> treeIterator= resource.getAllContents(); PublicationFactory factory = PublicationFactory.eINSTANCE; Publication publication = factory.createPublication();

String authors = null; while(treeIterator.hasNext()){

EObject object = treeIterator.next(); if (object instanceof Book){

publication.setTitle(((Book) object).getTitle()); } else {

String tmp = ((Chapter) object).getAuthor(); authors = publication.getAuthors(); if (authors != null){

authors = authors + "," + tmp; } else {

authors = tmp; } publication.setAuthors(authors); publication.setNbPages(

((Chapter) object).getNumPages() + publication.getNbPages()); }

resourceSet = new ResourceSetImpl();

resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put( Resource.Factory.Registry.DEFAULT_EXTENSION, new XMIResourceFactoryImpl());

fileURI = URI.createFileURI(new File("mypublication.xmi").getAbsolutePath());

// Create a resource for this file. resource = resourceSet.createResource(fileURI);

// Add the publication objects to the contents. resource.getContents().add(publication);

// Save the contents of the resource to the file system. try {

resource.save(Collections.EMPTY_MAP); } catch (IOException e) {} }

} // end of class

Generated Model myPublication.xmi

<?xml version="1.0" encoding="ASCII"?>

<publication:Publication xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:publication="http:///publication.ecore" title="Java" nbPages=“25" authors="Deitel,Jose"/>

Flora (F-Logic) Flora (F-Logic) IntroductionIntroduction

Flora-2 is a sophisticated object-oriented knowledge base language and application development platform.

FF-LLogic tRARAnslator Realizes the vision of logic-based KR with frames, meta, and

side-efects. Founded on F-logic HiLog Transaction Logic

Practical & usable KR and programming environment Declarative Object-oriented Logic-programming style Overcomes most of the usability problems with Prolog

Flora (F-Logic) Flora (F-Logic)

Implements Structural and Behavioural Inheritance with support for Single-source Multiple Inheritance

Flora is an implementation for F-logic over XSB Prolog Frame Logic is an object oriented deductive database

language Syntactical integration between Object Oriented Paradigm

and Rules Combines expressivity and declarative semantics to object

oriented concepts.

Flora - MetaModelFlora - MetaModel

Sequential Transaction Frame Logic Programming

Sequential Transaction Logic Programming

Frame Logic Programming

General Logic Programming

Hilog Logic Programming

Definit Logic Programming

DLP Package

DLP::Core

criminal(X) :- american(X), sellsWeaponsTo(X,cuba).american(X) :- bornIn(X,usa).bornIn(west, usa).

Program

Exemple:

ClauseExemple:

LogicalPredicativeAtomExemple:

QueryExemple:

OperatorExemple:

DLP::Operations

a :- b , c.

DLP::Operations

a :- b ; c.

DLP::Atom

ff(a,b)g(A,2)

DLP::Terms

2x2.78“teste”f(“teste”)

GLP::Operators

solteiro(P) :- homem(P), not casado(P).

HLP::Atom

fecho(R)(X,Y) :- R(X,Y).fecho(R)(X,Y) :- R(X,Z), fecho(R)(Z,Y).

STLP::Atom

STLP::Operators

newRule :- insert{p(X, Y) :- q(Y,Z)}, delete{p(2)}.

LogicalBacktrackableUpdateAtom

FLP::PathExpression

FLP::Atom

F-Logic OO ConceptsF-Logic OO Concepts

F-Logic

C[M->V]

C[M->>V]

C[M=>V]

C[M=>>V]

C[M*->V]

C[M*->>V]

C[M*=>V]

C[M*=>>V]

Taxonomic F-Atom

SignatureSpecification

ValueSpecification

Multiplicity: multi

Multiplicity: single

Inheritable

Non-Inheritable

F-Logic OO ConceptsF-Logic OO Concepts

X:aposentado :- X[idade->I], I>65.

mary[spouse->john].

mary[spouse->joe].

john[son*->>frank].

Definição de hierarquia de classes (SubclassFAtom) cachorro :: mamifero, jacare :: reptil mamifero :: animal, reptil :: animal

Definição de relações entre objetos/classes (InstanceFAtom): cao1 : cachorro, jacare1 : jacare

Definição de valores de atributos e métodos (AttributeValueSpecification / MethodValueSpecification): cao1[qtdPatas -> 4], joao[salario(2005)->1200]

Definição dos valores e tipos herdáveis para atributos e métodos de classes (AttributeValueSpecification / MethodValueSpecification – inheritable = true): cachorro[qtdPatas *-> 4], empregado[salario(2005)*->1200]

Definição de valores de atributos e métodos (AttributeValueSpecification / MethodValueSpecification): cao1[qtdPatas -> 4], joao[salario(2005)->1200]

Tipos de F-Atoms

Transformation ExampleTransformation Example

FloraFlora

Exemplo:

Livro[Titulo => string, capitulos =>> Capitulo[Numpaginas => integer, Titulo => string, Autor => string]].

Publicacao[Titulo => string, Numpaginas => integer, Autores =>> string].

P:Publicacao[Titulo -> T, Numpaginas -> N, Autores -> As] :- L:Livro[Titulo -> T, capitulos ->> C], N = sum{M|C[Numpaginas -> M]}, As = collectset{A|C[Autor -> A]}.

Livro2Publicacao :- L:Livro[Titulo -> T, capitulos ->> C], N = sum{M|C[Numpaginas -> M]}, As = collectset{A|C[Autor -> A], Ltinsert{Publicacao[Titulo -> T, Numpaginas -> N, Autores -> As]}.

XSLTXSLT

eXtensible Stylesheet Language Transformation (XSLT) Language (XML) for creation of documents that contains

rules for processing XML documents. Documents written in XSLT are called leaves of styles and contain:

Element XSLT: <template>, <if>, <foreach>, … Expression XPath us to find the tree-source Text or XML to be generated in the document-result.

XSLTXSLT

XSLT – How?XSLT – How?

In the process of transformation, XSLT uses XPath to define parts of the document of origin which combine with one or more moulds.

When a combination is found, XSLT transform the combinante part of the document of origin in the outcome document of.

Parts of the document of origin that do not match a template will remain unchanged in the outcome document.

XSLT – TransformationsXSLT – Transformations

XMLDocument 1

XMLSDocument 1

XSLTDocument

XSLTEngine

SourceSchema

FragmentMatchingPatterns

XMLDocument 2

XMLSDocument 2

TargetSchema

FragmentInsertion Actions

MatchedSource Fragments

Transformation process: Source document matching patterns XSLT document specifying actions that copy matched elements and

attributes from source document and assemble them in a novel way Target document matching transformations

XSLT – Example of Transformation 1/3XSLT – Example of Transformation 1/3

Consider the following document-source:<aeronave id="PTGWZ"><origem partida="08:15">Rio de Janeiro</origem><destino>Itabuna</destino></aeronave>

The following template (part of a style sheet XSLT) can extract data from the source document.

XSLT elements are generally used with a prefix related to its namespace: <xsl:elemento> to avoid conflicts with the document-result. After processing the result will be:

<p>A aeronave de prefixo

PTGWZ decolou

de Rio de Janeiro às

tendo como destino o aeroporto de

Itabuna.</p>

XSLT – Other example.XSLT – Other example.

Example:

<package id="pck1" name=“library"> <class id="c1" name=“Livro"> <association aggregationType="composite" id="c1_ass1" name=“capitulos"

targetClass="c2"/> <attribute cardinality="1..1" id="c1_atr1" name=“Titulo" type="dt1"/> </class> <class id="c2" name=“Capitulo"> <attribute cardinality="1..1" id="c2_atr1" name=“Numpaginas" type="dt2"/> <attribute cardinality="1..1" id="c2_atr2" name=“Titulo" type="dt2"/> <attribute cardinality="1..1" id="c2_atr3" name=“Autor" type="dt1"/> <association aggregationType="none" id="c2_ass1" name=“Livro"

targetClass="c1"/> </class> </package></model>

Source file: livro.xmi

XSLT – Other Example.XSLT – Other Example.

Example:

<?xml version="1.0" encoding="UTF-8"?><xsl:transform version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform" > <xsl:output method="xml" /> <xsl:template match=“publicacao.Livro" > <xsl:variable name=“Titulo" select="@Titulo" /> <xsl:variable name=“Autores" select="concat(@capitulos.autor, ',')"/> <xsl:variable name=“Numpaginas" select="sum(@capitulos.Numpaginas)"/>

<xsl:call-template name="createPublication"> <xsl:with-param name=“Titulo" select="$Titulo"/> <xsl:with-param name=“Autores" select="$Autores"/> < xsl:with-param name=“Numpaginas" select="$Numpaginas"/> </xsl:call-template> </xsl:template></xsl:transform>

Source file: Livro2Publicacao.xslt

XSLT – Other example.XSLT – Other example.

Example:

<package id="pck1" name=“library"> <class id="c1" name=“Publicação"> <attribute cardinality="1..1" id="c1_atr1" name=“Titulo" type="dt1"/> <attribute cardinality="1..1" id="c1_atr2" name=“Numpaginas"

type="dt2"/> <attribute cardinality="1..1" id="c1_atr3" name=“Autores"

type="dt1"/> </class> <datatype id="dt1" name="String"/> <datatype id="dt2" name="Integer"/> </package></model>

Source file: Publicacao.xmi

QVTQVT

Standard for model transformation proposed by OMG RFP issued by OMG on MOF Query/Views/Transformations Key ideas

Source and target models conform to MOF metamodels. Transformation program as a model

Hybrid nature Two level declarative model

QVT OverviewQVT Overview

Core Pattern matching over a flat set of variables Defined using minimal extensions to EMOF and OCL Fine grained (one mapped identity per rule) Simple transformation language

Relations Object pattern matching and object template creation Coarse grained (many mapped identities per rule) Specification of relations over model elements

Operational Procedural definition Extends Relations language with imperative constructs Two mechanisms for invoking imperative implementations

Operational Mapping (standard) Black box MOF Operations implementations

Relationship between Relations and CoreRelationship between Relations and Core

Core is a small extension of EMOF classes and OCL expressions manipulates trace models explicitly

Relations adds extended pattern syntax implicit trace models

Both languages have a similar evaluation semantics multi-direction execution incremental update / change propagation semantics implicit object creation and deletion

Relations is mapped (reduced) to Core to provide its full semantics

QVT - Package dependenciesQVT - Package dependencies

Relation Language – Abstract SyntaxRelation Language – Abstract Syntax

QVT – Relation LanguageQVT – Relation Language

Relation Transformation between candidate model is specified as a set of relations

that must hold

transformation umlRdbms (uml : SimpleUML, rdbms : SimpleRDBMS) { }

A relation declare constraints that must be satisfied by the elements of candidate models

Domains When Pattern Where Pattern

Domaindistinguished typed variable that can be matched in a model

of a given model typeA domain has patterns

Set of variables and a set of constraints that model elements bound to those variables must satisfy to qualify as a valid binding of the pattern

relation PackageToSchema /* map each package to a schema */ { domain uml p:Package {name=pn}

domain rdbms s:Schema {name=pn} }

Whenspecifies the conditions under which the

relationship needs to hold Where

specifies the condition that must be satisfied by all model elements participating in the relation

The when and where clauses may contain any arbitrary OCL expressions in addition to the relation invocation expressions.

Example QVT RelationalExample QVT Relational

QVT - Core LanguageQVT - Core Language

Transformation consists of a number of Mapping Rules.

Each Mapping Rule consists of a constellation of Patterns

Patterns consist of variables and OCL expressions. A binding of a pattern is a unique set of values for all

of its variables, for which all the OCL expressions hold

Core Language - Abstract SyntaxCore Language - Abstract Syntax

QVT – Core LanguageQVT – Core Language

Domain Has an associated model type of the transformation (model candidates)

Area Consists of two patterns

Pattern Set of variables, predicates and assignments Can be matched or enforced Can depend on each other

Guard Pattern Narrow the selection of model elements to be considered for the mapping Only used for defined a context

Bottom Pattern Defines the derivations Can have realized variables, assignments and black-box operation

Mapping One are for the trace and one for each model type Defines a relation between bottom patterns

Mapping Rule ExampleMapping Rule Example

c : Class

a : Attribute |a.class := c;

c2t : ClassTable |c2t.table = t;c2t.class = c;

t : Table

a2c : AttrColumn |a2c.owner := c2t;

a2c.attr := a;a2c.column := c;

c : Column |c.table := t;

Class to Table

Attribute to Column

UML RelationalUML/Rel

Bottom pattern is evaluated using the variable values of the valid binding of the guard pattern.

Core/Relational comparisonCore/Relational comparison

Aspects that have to be defined explicitly when using core language The patterns that match against, and create the instances of the

classes that are the trace objects of the transformation (e.g. the links between the transformed model elements).

Atomic sets of model elements that are created or deleted as a whole, specified in smaller patterns than commonly specified in the Relational Language.

QVT Operational – Abstract Syntax QVT Operational – Abstract Syntax

QVT - Operational LanguageQVT - Operational Language

Operational Transformations Definition of a unidirectional transformations that is expressed

imperatively Its signature defines

Models involved in transformation Entry operation for execution

QVT - Operational LanguageQVT - Operational Language

Mapping operation that implements a mapping between one or more source

model elements into one or more target model elements.

Libraries contains definitions that can be reused by transformations It may define specific types and may define operations

QVTQVT

Helper Allow writing complex navigations in a confortable way Reuse

Model Transformation expressed inModel Transformation expressed inOperational Mappings LanguageOperational Mappings Language

Overall structure of a transformation program:

metamodel 'http://www.borland.com/together/uml20';transformation BookToPublication (in InputMetamodel):

OutputMetamodel…………………………………………………………………

main () {…………………………………………………………………

…………………………………………………………………

…helpers……………………………………………

…mapping operations………………

…………………………………………………

Signature:Declares the identifier of the transformation

Entry point:The execution of the transformation starts here by executing the operations in the body of main.It also declares the source and target metamodels. in keywords indicate source and target model variables. The target is represented by the return of main.

Transformation elements:Transformation consists of mapping operations and helpers. They form the transformation logic.

BookToPublication Example in the BookToPublication Example in the OMG QVT SpecificationOMG QVT Specification

metamodel BOOK { class Book {title: String; composite chapters: Chapter;} class Chapter {title : String; nbPages : Integer;} }metamodel PUB { class Publication {title : String; nbPages : Integer;} }

transformation Book2Publication(in bookModel:BOOK,out pubModel:PUB)

main() { bookModel->objectOfType(Book)->map book_to_publication(); }mapping Class::book_to_publication () : Publication { title := self.title; nbPages := self.chapters->nbPages->sum();}

Java FLORA XSLT QVT

Concise + + - +/-

well-know languages - - + -

Efficient + + - -

Executable + + + -

Expressive + + + +

Metamodel + + - +

Formal semantics - + - -

Standards + - +/- +

All OO/MOF concepts + +/- +/- +

Tools + - - +/-

Comparation Table Comparation Table

Legend:+:requirement well fulfilled +/-: requirement partially, weakly, impractically fulfilled -: not fulfilled

ConclusionsConclusions

Model Transformations are assetsguided by sound Soft. Engineering principles

Analysis, Design, Implementation, V & V (Test), and Configuration Management (evolution)

Transformations should also be models (principles of MDE) In order to tackle complexity

ReferencesReferences

http://en.wikipedia.org/wiki/QVT http://en.wikipedia.org/wiki/XSLT http://en.wikipedia.org/wiki/VIATRA http://en.wikipedia.org/wiki/GReAT http://en.wikipedia.org/wiki/Visitor_pattern http://modelware.inria.fr http://www.modelware-ist.org (Main Repository Page \ Training) http://www.eclipse.org/gmt/EMF Czarnecki and Helsen: Classification of Model Transformation

Approaches. Shane Sendall and Wojtek Kozaczynski: Model Transformation – the

Heart and Soul of Model-Driven Software Development Anna Gerber at al: Transformation: The Missing Link of MDA QVT Specification Dariusz Gall, Michal Molenda: EDOC to EJB transformations within

Model Transformations "Rien ne se perd, rien ne se crée, tout se transforme." Antoine-Laurent de...

Documents

Transcript of Model Transformations "Rien ne se perd, rien ne se crée, tout se transforme." Antoine-Laurent de...

Ça ne coûte rien de lire. Ça ne coûte rien d'essayer !!! à voir... Mais bien lire jusqu'en bas Ça ne coûte rien d'essayer !!! à voir... Mais bien lire.

Premier principe de thermodynamique « Rien ne se perd, rien ne se crée, tout se transforme » (Lavoisier) L'énergie totale au cours d'une réaction reste.

Rien ne se crée, rien ne se perd - CDÉACF

Ça ne coûte rien de lire Ça ne coûte rien d'essayer !!! à voir....mais bien lire jusqu'en bas Ça ne coûte rien d'essayer !!! à voir....mais bien lire.

Rien pour nous ne se fera sans nous PRÉSENTENT.

3 trucs pour ne rien oublier

Griezmann, rien ne va plus

Je dis que rien ne m'epouvante

Académie : Session NE RIEN NE RIEN ÉCRIRE DANS CETTE ...

« Je n'espère rien, je ne crains rien, je suis libre.

NE RIEN DECLARER REVIENT À ACCEPTER DE SE …05... · NE RIEN DECLARER REVIENT À ACCEPTER DE SE FAIRE AVOIR ! POURQUOI ? Les directeurs sont confrontés à un problème : -« La

Rien ne se crée sans les hommes. Rien ne dure sans les ...rjea.ier.gov.ro/wp-content/uploads/revista/RJEA_2012_vol12_no1_final.pdf · 2007-2013. E-mail: miruna.troncota@yahoo.com.

Rien ne se crée sans les hommes. Rien ne dure sans les ...rjea.ier.ro/sites/rjea.ier.ro/files/revista/rjea_vol.12_nr.2_site.pdf · Rien ne dure sans les institutions. Jean Monnet

Huit cadeaux qui ne coûtent rien

QUE JE NE SAIS RIEN

Les vraies merveilles ne coûtent rien

+ La négation!. + Les expressions négatives ne... pas ne... plus ne... rien / rien ne... ne... jamais / jamais ne... ne... personne / personne ne... ne...

Ca ne coûte rien de lire ....

L’Institut Supérieur des Sciences Hajji... · Web viewObéissant au principe de Lavoisier (« rien ne se perd, rien ne se crée, tout se transforme »), la réduction n’est qu’apparente

ÉCONOMIE - cci.fr · Economie circulaire L’économie circulaire peut se définir à l’image de ce que fait la nature : « rien ne se perd, rien ne se crée, tout se transforme