ATL Transformations

Ant is an open source build tool (a tool dedicated to the assembly of the different pieces of a program) from the Apache Software Foundation. Ant is the most commonly used build tool for Java programs. Maven is another build tool created by the Apache Software Foundation. It is an extension of Ant because ant Tasks can be used in Maven. The difference from Ant is that a project can be reusable. This example describes a transformation from an Ant file to Maven files (project.xml and maven.xml).

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is to weakening preconditions or strengthening postconditions. This example was extracted by Eric Simon.

The ATL2BindingDebugger ATL transformation adds a debug instruction to each binding in an ATL transformation.

Source and target models conform to ATL metamodel. A sample source model (sample-ATL-0.2.ecore) and its corresponding target model (Sample-ATL-0.2(Debug).ecore) are given.

The ATL to Problem example describes a transformation from an ATL model into a Problem model. The generated Problem model contains the list of non-structural errors (along with additional warnings) that have been detected within the input ATL model. The transformation assumes the input ATL model is structurally correct, as those that have passed a syntactic analysis (for instance, a reference defined with cardinality [1-1] should not be undefined).

The ATL2Tracer transformation shows how traceability generating code can be relatively easily added to ATL code. It moreover shows that this process can be fully automated.

To find more details concerning dealing traceability in ATL, please refer to [1].

Source and target models conform to ATL metamodel. A sample source model (sample-ATL-0.2.ecore in ATL2Tracer folder) and its corresponding target model (sample-ATL-0.2-Tracer.ecore in Tracertest/Input) are given.

References:

• [1] Jouault, F : Loosely Coupled Traceability for ATL. In: Proceedings of the European Conference on Model Driven Architecture (ECMDA) workshop on traceability, Nuremberg, Germany.

The BibTeXML to DocBook example describes a transformation of a BibTeXML model to a DocBook composed document. BibTeXML is an XML-based format for the BibTeX bibliographic tool. DocBook, as for it, is an XML-based format for document composition.

The Book to Publication example describes a very simple transformation task. In the metamodel Book the class Book contains an ordered set of Chapters. These Chapters hold the information of the number of pages of Chapters. The metamodel Publication is simpler; its class Publication contains a title and the total number of pages. For the transformation, all chapters of a Book have to be visited to calculate the sum of all pages.

All transformations have been extracted from the catalogue of models transformations: http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf. From this catalogue, the following ATL transformations have been created:

• Assertion Modification
• Disaggregation
• Eliminate Redundant Inheritance
• Equivalence of attributes and associations
• Introduce Primary Key
• Introducing an interface
• Making partial role total
• Merging Partial Classes
• Raise Supplier Abstraction Level
• Redundant Class Removable
• Removing a Many Many Association
• Removing An Association Class
• Replace association by foreign key
• Replace inheritance by association

They were extracted by Eric Simon and Julien Baudry.

The Class to Relational example describes the simplified transformation of a class schema model to a relational database model.

This example describes a transformation from the text result generated by code clone detection tools into SVG code in order to realize an uniform representation for different code clone analysis result. At first, specific DSLs for different code clone tools (Simian, simScan, CloneDr) are defined. Then these models can be transformed to a generic DSL for Code Clone. Then, the generic model will be transformed to SVG model. Finally, SVG code can be extracted from the SVG model.

This example handles several aspects of two telephony DSLs: SPL and CPL.

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this example is the following: "A class may become large and unmanageable, with several loosely connected functionalities. It should be split into several classes, such as a master/controller class and helper classes, which have more coherent functionalities and data." This example was extracted by Eric Simon.

This example provides you a complete overview of a transformation chain example between two technical spaces: Microsoft DSL (Domain Specific Languages) Tools and EMF (Eclipse Modeling Framework). The aim of this example is to demonstrate the possibility to exchange models defined under different technologies. In particular, the described bridges demonstrate that it should be possible to define metamodels and models using both Microsoft DSL Tools and Eclipse EMF technologies. The bridge between MS/DSL and EMF spans two levels: the metamodel and model levels. At the level of metamodels, it allows to transform MS/DSL domain models to EMF metamodels. At the level of models, the bridge allows transforming MS/DSL models conforming to domain models to EMF models conforming to EMF metamodels. At both levels, the bridge operates in both directions. A chain of ATL-based transformations is used to implement the bridge at these two levels. The benefit of using such a bridge is the ability to transpose MS/DSL work in EMF platform, and inversely.

This example is extract from Catalogue of Model Transformations by K. Lano. "A redundant inheritance conveys no extra information, but complicates the model. The previous figure shows a typical situation where class A directly inherits from class C, and also indirectly via a more specific class B. The first inheritance is redundant and can be removed. (In some languages, such as Java, such inheritances would actually be invalid)." This example was extracted by Julien Baudry.

The KM3 plugin implements several transformations, including the generation of a KM3 model from an Ecore metamodel: EMF2KM3. This distribution provides source code for the EMF2KM3 transformation available in the KM3 plugin as of December 12th, 2005.

EMF2KM3 is usually used through the KM3 plugin, as the "Extract Ecore metamodel to KM3" action available on *.ecore files. Some users may however want to customize this transformation. Here is the procedure to replace the standard transformation with a custom one:

• modify EMF2KM3.atl to support desired features,
• compile it into EMF2KM3.asm (this is normally automatically performed by the ATL builder),
• copy EMF2KM3.asm into org.atl.eclipse.km3 / src / org / atl / eclipse / km3 / resources,
• restart Eclipse.

This example is extract from Catalogue of Model Transformations by K. Lano. Qualified association cannot be represented as attributes, as there is no corresponding attribute notation, i.e., for specifying map data structures. In addition the multiplicity at the owning entity end of an association cannot be generally expressed in the attribute version. For an ordinary attribute this multiplicity is * and for an identity attribute (primary key) it is 0..1. This example was extracted by Julien Baudry.

This is the source code of the ATL Use Case: "Families to Persons". This use case describes a very simple model transformation example, some kind of ATL "hello world".

The FM to BPMN example describes a transformation from a feature model for representing runtime variability in business information systems created using FAMA (FeAture Model Analyzer) into a business process model diagram represented by means of BPMN metamodel provided by the Eclipse STP (SOA Tool Platform) project.

This document illustrates an advanced ATL program in the area of geometrical transformations. This transformation example describes geometrical transformations. Input of the transformation are geometrical operations (rotate, move, explode) and geometrical data (based on a simplified DXF metamodel). The output of the transformation is the geometrical data (based on the same simplified DXF metamodel) that has been transformed according to the geometrical operations. DXF^TM, Drawing eXchange Format, is the native vector file format of Autodesk's AutoCAD CAD application. DXF features include support for 3D objects, curves, text and associative dimensioning. Particularity of the transformations is that it has two input metamodels and that one of the input metamodels is the same as the output metamodel.

This ATL example describes bridges between Grafcet, Petri net, PNML, and XML. This example provides an overview of the whole transformation sequence that enables to produce an XML Petri net representation (in the PNML format) from a textual definition of a grafcet. It also describes the reverse transformation sequence that enables to build a textual grafcet representation from an XML definition of a PNML document.

This ATL example realizes the transformation between IEEE1471-2000 and MoDAF-AV. The IEEE1471 committee precises a recommended practice for the design and the analysis of Architecture of Software Intensive Systems. It fixes a terminolgy for System, Architecture, Architectural Description, Stakeholder, Concerns, View ,and Viewpoints concepts. MoDAF (Ministry of Defense Architecture Framework) is based on the DoDAF (Departement of Defense Architecture Framework). DoDAF is a framework to design C4ISR systems. MoDAF-AV (Architecture View) used several concepts defined in the IEEE1471. IEEE1471 to MoDAF was produced by Albin Jossic.

This example is extract from Catalogue of Model Transformations by K. Lano. This is an essential step for implementation of a data model in relational database. This example was extracted by Julien Baudry.

This example is extract from Catalogue of Model Transformations by K. Lano. This reduces the dependencies in the model and enables separate development of A and B, and permits them to be placed in different layers or tiers of the system. This example was extracted by Julien Baudry.

The JavaSource to Table example describes a transformation from a Java source code to a table which summarizes how many times each method declared in the Java source code is called within the definition of any declared method. A XML-based format, inspired from the JavaML, has been developed to encode all interesting information available in the Java source code. We use, for this transformation, a very basic abstract Table model which may be easily mapped to existing table representations (XHTML, ExcelML, etc.).

The KM32ATLCopier transformation creates a transformation of copy for a KM3 model. Source model conforms to KM3 metamodel and target model conforms to ATL metamodel. A sample source model (sample-KM3.ecore) and its corresponding target model (ATLCopier.ecore) are given.

This package includes a higher-order transformation (HOT) that, based on a metamodel (i.e., an injected KM3 model), generates a transformation that checks the consistency of two source models that conform to that metamodel. The target model of the (generated) transformation effectively is the union of the two source models with its elements and relations labelled as convergent, divergent, or absent according to their occurrence in one or both of the source models. The HOT provides a means to generically check to conformance of models associated with simple metamodels.

The KM3 to DOT example describes a transformation from a KM3 metamodel description into a class diagram drawn with DOT. KM3 is a textual concrete syntax to describe metamodels. It has its advantages, yet having a graphical presentation of a metamodel can be sometimes enlightening. DOT is an automatic graph layout program from Graphviz. It can be used to create graphical files, such as PS, PNG... out of its layout. The aim of this transformation is to generate a rough visualization, in the form of a class diagram, of a KM3 model. A metamodel created with KM3 does not include any representation information, so DOT, the Graphviz tool, is used to compute the layout and generate the output picture.

The KM3 plugin implements several transformations, including the generation of an Ecore metamodel from a KM3 model: KM32EMF. This distribution provides source code for the KM32EMF transformation available in the KM3 plugin as of May 24th, 2006.

KM32EMF is usually used through the KM3 plugin, as the "Inject KM3 to Ecore metamodel" action available on *.km3 files. Some users may however want to customize this transformation. Here is the procedure to replace the standard transformation with a custom one:

• modify KM32EMF.atl to support desired features,
• compile it into KM32EMF.asm (this is normally automatically performed by the ATL builder),
• copy KM32EMF.asm into org.atl.eclipse.km3 / src / org / atl / eclipse / km3 / resources,
• restart Eclipse.

The KM3 to Measure example describes measurement on KM3 metamodels, using metrics defined as ATL libraries. This scenario is an updated version of the scenario KM32Metrics. It is contributed by Eric Vépa (SODIUS).

Due to the even growing complexity of metamodels, the establishment of metamodel metrics now requires the use of dedicated tools. This ATL transformation example aims to show how the ATL language may be used to meet this objective by generating metrics models from metamodels. The Kernel MetaMetaModel (KM3) is a simple textual notation enabling quick definition of metamodels. The KM3 to Metrics ATL example aims to demonstrate the feasibility of computing some metamodel metrics by means of the ATL language. For this purpose, we have developed a basic Metrics metamodel enabling to encode measures of different types. The KM3 to Metrics ATL transformation defines different metamodel metrics that are relative either to the whole model, or to specific model elements. The metrics provided in the scope of this transformation include simple measurements as well as more complex computations.

This ATL scenario shows up a traduction of KM3 into OWL (Web Ontology language) ontology language. This scenario is composed of one transformation (KM32OWL) and an OWL extractor that produces XML documents conform to the OWL syntax defined by the W3C. Resulting ontology can be used into ontology development tools like Protege (see http://protege.stanford.edu).

The KM3 to Problem example describes a transformation from a KM3 metamodel into a Problem model. The generated Problem model contains the list of non-structural errors (along with additional warnings) that have been detected within the input KM3 metamodel. The transformation assumes the input KM3 metamodel is structurally correct, as those that have passed a syntactic analysis (for instance, a reference defined with cardinality [1-1] should not be undefined). It may therefore fails when executed on a KM3 metamodel produced from a MOF metamodel that has not been checked.

The KM3 to XML scenario expresses each metamodel written in KM3 textual syntax with a default XML syntax. As a default syntax, it is not the more concise but it is non-ambiguous and can be apply to any KM3 model.

The KMLInjector example describes a transformation from a KML file to a KML model. KML, or Keyhole Markup Language, is an XML grammar and file format for modeling and storing geographic features such as points, lines, images, and polygons for display in Google Earth.

In this example, we present some basic concepts of ATL through a simple use case. Our working context is to create a bridge between two different versions of a List metamodel (A and B versions). This bridge consists on an ATL transformation from the metamodel A to the metamodel B.

Ant is an open source build tool (a tool dedicated to the assembly of the different pieces of a program) from the Apache Software Foundation. Ant is the most commonly used build tool for Java programs. Unlike many other build tools, Ant is independent of both the platform and the development environments. Make (the most common build tool) is based on a particular shell or command interface and is therefore limited to the type of operating systems that use that shell. Ant uses Java classes rather than shell-based commands. Developers use XML to describe the modules in their program build. This example describes a transformation from a Makefile to an Ant file.

This example is extract from Catalogue of Model Transformations by K. Lano. Total associations are generally easier to implement and manage than partial associations. This example was extracted by Julien Baudry.

Ant is an open source build tool (a tool dedicated to the assembly of the different pieces of a program) from the Apache Software Foundation. Ant is the most commonly used build tool for Java programs. Maven is another build tool created by the Apache Software Foundation. It is an extension of Ant because ant Tasks can be used in Maven. The difference from Ant is that a project can be reusable. This document describes a transformation from a Maven files (project.xml and maven.xml) to an Ant file.

The Measure2Table project is used to creates generic tables from a measure model. This scenario is used by the scenario Model Measurement. It is contributed by Eric Vépa (SODIUS).

The Measure to XHTML example describes a transformation from a Measure model to a XHTML file representing the measurement data. This scenario is used by the scenario Model Measurement. It is contributed by Eric Vépa (SODIUS).

The Measuring Model Repositories example generates some measures (graph and table format) on input KM3 models. This example describes three transformations from a KM3 model to a Measure model, from a Measure model to a Measure model and from a Measure model to a Table model. Finally, graphical outputs are generated (SVG and HTML).

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is to merge the class link by a association one-one. This example was extracted by Eric Simon.

The MetaH to ACME example describes a transformation from a MetaH format to ACME format. The ACME interchange format was originally conceived as a way to share tool capabilities rovided by a particular ADL with other ADLs, while avoiding the production of many pair wise language translators. The MetaH architectural description language (ADL) and associated toolset support architectural modeling of embedded real-time system applications. MetaH to ACME was produced by Julien Baudry.

This use case shows how we can reuse UML projects created with Rational Rose and import them in GMF (specifically in UML2 Tools) using ATL transformations.

The ModelsMeasurement project is used to collect measurement data on KM3 metamodels or UML2 models, using libraries implementing some metrics (MOOD, MOOD2, MOOSE, EMOOSE and QMOOD). The measure level can be changed by setting an other value for the first helper measureLevel of the transformation KM32Measure or UML22Measure. This scenario is contributed by Eric Vépa (SODIUS).

The MOF (Meta Object Facility) is an OMG standard enabling to describe metamodels through common semantics. The UML (Unified Modelling Language) Core standard is the OMG common modelling language. Although, the MOF is primarily designed for metamodel definitions and UML Core for the design of models, the two standards handle very close notions. This example describes a transformation enabling to pass from the MOF to the UML semantics. The transformation is based on the UML Profile for MOF OMG specification.

The Monitor to Semaphore example describes a transformation from a program containing Hoares monitors definitions into an equivalent program in which synchronization operations are based on Dijkstras semaphores. This is an example of end-to-end transformation, from code to code. It strictly follows the operational semantic of monitors described in terms of semaphores and shows how this abstract description may be implemented into an executable ATL transformation.

The Microsoft Office Excel extractor's example describes a transformation from an Excel model to an Excel workbook. The transformation is based on a simplified subset of the SpreadsheetML XML dialect which is the one used by Microsoft to import/export Excel workbook's data in XML since the 2003 version of Microsoft Office. This transformation produces an Excel XML file which can be directly opened by Microsoft Excel 2003. This file describes a workbook with the same content that the one of the input Excel model.

The Microsoft Office Excel injector's example describes a transformation from an Excel workbook to an Excel model. The transformation is based on a simplified subset of the SpreadsheetML XML dialect which is the one used by Microsoft to import/export Excel workbook's data in XML since the 2003 version of Microsoft Office. This transformation produces an Excel model from an Excel XML file which can be directly opened by Excel 2003. This Excel model describes a workbook with the same content that the one stored into the input Excel XML file.

The "Microsoft Office Excel to Software Quality Control" example describes a transformation from an Excel workbook containing information about quality controls of a software product to a model storing the same data in a more general and abstract structure. The transformation is based on a simplified subset of the SpreadsheetML XML dialect which is the one used by Microsoft to import/export Excel workbook's data in XML since the 2003 version of Microsoft Office. It is also based on a Software Quality Control metamodel which describes a simple structure to manage software quality controls (for example bug-tracking). The input of the transformation is an Excel XML file, containing the description of the Excel workbook, which can be directly opened by Excel 2003. The output is a model which conforms to the SoftwareQualityControl metamodel.

The MySQL to KM3 transformation describes a transformation from the description of a relational database to metamodel semantics. The example aims to demonstrate the possibility to translate data structure description from the RDBMS to the modelling technical space. For this purpose, the popular open source MySQL RDBMS system has been considered as the database platform, and the KM3 notation as the metamodel description tool.

OpenBlueLab project's ambition is to provide an application which you can adapt easily by just updating UML models contained in the OpenBlueLab download, without writing any line of code. OpenBlueLab use as input XMI file but too OBL file conforms to our specialized metamodel used to generate a particular editor, OpenBlueLab Developer Studio. So we have made a transformation which permit to get XMI file conforms to the metamodel UML from OBL file if we want to re-integrate OBL models in UML modeler.

This scenario is a contribution from Benjamin Chevallereau (OpenBlueLab).

The OCL to R2ML transformation scenario describes a transformation from OCL (Object Constraint Language) metamodel (with EMOF metamodel) into a R2ML (REWERSE I1 Rule Markup Language) metamodel. The Object Constraint Language (OCL) is a language that enables one to describe expressions and constraints on object-oriented (UML and MOF) models and other object modeling artifacts. An expression is an indication or specification of a value. A constraint is a restriction on one or more values of (part of) an object-oriented model or system. REWERSE I1 Rule Markup Language (R2ML) is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages, in this case with the OCL.

This scenario is a contribution from Milan Milanovic.

The OCL to SWRL transformation scenario describes a transformation from OCL (Object Constraint Language) metamodel (with EMOF metamodel) into a R2ML (REWERSE I1 Rule Markup Language) metamodel and then to the SWRL (Semantic Web Rule Language) metamodel (RDM) with ODM (OWL language metamodel). The Object Constraint Language (OCL) is a language that enables one to describe expressions and constraints on object-oriented (UML and MOF) models and other object modeling artifacts. An expression is an indication or specification of a value. A constraint is a restriction on one or more values of (part of) an object-oriented model or system. REWERSE I1 Rule Markup Language (R2ML) is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages, in this case with the OCL. SWRL is a web rule language based on combination of the OWL DL and OWL Lite sublanguages of the OWL Web Ontology Language, with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language (RuleML).

This scenario is a contribution from Milan Milanovic.

The path expression to Petri nets example describes a transformation from a path expression to a Petri net. This document provides an overview of the whole transformation sequence that enables to produce an XML Petri net representation (in the PNML format) from a textual definition of a path expression. Its also describes the reverse transformation sequence that enables to build a textual path expression representation from a XML definition of a Petri net (in the PNML format).

In this example, we present some basic concepts of ATL through a simple use case. This use case deals with situations where the source element meta type could not be simply matched with the target meta type. The only way to resolve the target meta type is to browse source model

The Public2Private ATL transformation makes all public attributes of a UML 1.4 model private. Getters and setters are also created appropriately (i.e. no setter for a frozen attribute). This transformation uses ATL refining mode as defined in [1]. Thanks to refining mode, only two rules have to be written: one for read-only (i.e. "frozen" in UML terminology) attributes and one for read-write attributes.

Source and target models conform to UML the 1.4 metamodel provided as UMLDI.xmi. A sample source model (PetriNet.xmi) and its corresponding target model (PetriNet-Privatized.xmi) are given. Both models are also given in PNG format for easy visualization: PetriNet.png and PetriNet-Privatized.png. Additional source models may be created using Poseidon (http://www.gentleware.com/).

References:

• [1] Jouault, F., and Kurtev, I., Transforming Models with ATL, in proceedings of the Model Transformation in Practice Workshop, October 3rd 2005, part of the MoDELS 2005 conference

This work provides a QVT compiler that targets the ATL Virtual Machine (ATL VM). The code generator is written in the ACG (Atl Code Generation) Domain-Specific Language (DSL), which is a domain-specific model transformation language (its domain is ATL VM bytecode generation, i.e., a fixed target metamodel). It takes as input a QVT model (typically in XMI format) that may have been created by a QVT front-end (i.e., a parser and type checker) like Procedural QVT, or SmartQVT. The output of the code generator is a ".asm" file similar to the ones generated by the ATL compiler, or the ACG compiler (both also written in ACG).

The R2ML to OCL transformation scenario describes a transformation from R2ML (REWERSE I1 Rule Markup Language) metamodel into a OCL (Object Constraint Language) metamodel (with EMOF metamodel). The Object Constraint Language (OCL) is a language that enables one to describe expressions and constraints on object-oriented (UML and MOF) models and other object modeling artifacts. An expression is an indication or specification of a value. A constraint is a restriction on one or more values of (part of) an object-oriented model or system. REWERSE I1 Rule Markup Language (R2ML) is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages, in this case with the OCL.

This scenario is a contribution from Milan Milanovic.

The R2ML to SWRL transformation scenario describes a transformation from R2ML (REWERSE I1 Markup Language) metamodel into a SWRL (Semantic Web Rule Language) metamodel (RDM). SWRL is a web rule language based on combination of the OWL DL and OWL Lite sublanguages of the OWL Web Ontology Language, with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language (RuleML). REWERSE I1 Rule Markup Language is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages, in this case with the SWRL.

This scenario is a contribution from Milan Milanovic.

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is: "a class may become large and unmanageable, with several loosely connected functionalities. It should be split into several classes, such as a master/controller class and helper classes, which have more coherent functionalities and data." This example was extracted by Eric Simon.

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is: "duplication of classes will lead to over-complex models which are difficult to modify and analyse." This example was extracted by Eric Simon.

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is: "association classes cannot be represented directly in many object-oriented programming languages." This example was extracted by Eric Simon.

This example is extract from Catalogue of Model Transformations by K. Lano. The purpose of this transformation is to substitute a many-many association by an introduction of class with two many-one associations. This example was extracted by Eric Simon.

This example is extract from Catalogue of Model Transformations by K. Lano. This transformation applies to any explicit many-one association between persistent classes. It assumes that primary keys already exist for the classes linked by the association. It replaces the association by embedding values of the key of the entity at the one end of the association into the entity at the many ends. This example was extracted by Julien Baudry.

This example is extract from Catalogue of Model Transformations by K. Lano. This transformation replaces an inheritance relationship between two classes by an association between the classes. This example was extracted by Julien Baudry.

RSS is a format for syndicating news and the content of news-like sites.

Atom is an XML-based file format intended to allow lists of information, known as "feeds", to be synchronised between publishers and consumers.

RSS to ATOM was produced by Youssef Srour.

This case deals with the way to handle side effects induced while transforming an element. We will start from an imperative algorithm to create a transformation between two metamodels. This algorithm will introduce a side effect problem. After several iteration a solution will be provided following ATL philosophy.

This transformation implements the case study used in the Workshop Model Transformations in Practice collocated with the MoDELS Conference, October, 2005. The description of the case study can be found at the workshop web site: http://sosym.dcs.kcl.ac.uk/events/mtip05/.

Two versions of the SimpleClass2SimpleRDBMS transformation have been developed:

• The first one, which is presented in [1], uses some ATL features that are not implemented in the engine yet. Its purpose is to illustrate the planned features of the language.
• The second one, coming with this README.txt, is another version that works with the ATL engine available on http://eclipse.org/gmt as of November 2005. This second version uses roughly the same helpers as the first version.

References:

• [1] Jouault, F., and Kurtev, I., Transforming Models with ATL, in proceedings of Model Transformations in Practice Workshop, October 3rd 2005, part of the MoDELS 2005 Conference

These transformations are part of a Course about metamodeling, models transformation and verification. These transformations introduce a property-driven approach to validate models through a translational semantics to Petri nets.

The Software Quality Control to Bugzilla example describes a transformation from a SoftwareQualityControl model to a simple Bugzilla XML file. Bugzilla is a free "Defect Tracking System" or "Bug-Tracking System", originally developed by the Mozilla Foundation, which allows individual or groups of developers to effectively keep track of outstanding bugs in their product. The transformation is based on a Software Quality Control metamodel which describes a simple structure to manage software quality controls (and more especially bug-tracking). The input of the transformation is a model which conforms to the SoftwareQualityControl metamodel. The output is an XML file whose content conforms to a simple Bugzilla DTD.

The Software Quality Control to Mantis Bug Tracker example describes a transformation from a SoftwareQualityControl model to a simple Mantis XML file. Mantis Bug Tracker is a free web-based bug-tracking system written in PHP that uses a MySQL database. The transformation is based on a Software Quality Control metamodel which describes a simple structure to manage software quality controls (and more especially bug-tracking). The input of the transformation is a model which conforms to the SoftwareQualityControl metamodel. The output is an XML file whose content conforms to a Mantis XML schema.

The SSL to SDL example describes a transformation which enables to create a SDL model from a SSL model, using an auxiliary ODM model that contains the ontology elements referred in the SSL model. SDL is a language for describing concrete service interfaces, from a technical point of view, while SSL can be used to create semantic descriptions of services. SSL models can refer to terms defined in an external ontology, therefore another metamodel, ODM, is used for querying ontologies.



This transformation and associated metamodels is a contribution from Irina Dumitrascu and Natalia Rebeja , Soluta.Net.

The SWRL to R2ML transformation scenario describes a transformation from SWRL (Semantic Web Rule Language) metamodel (RDM) into a R2ML (REWERSE I1 Markup Language) metamodel. SWRL is a web rule language based on combination of the OWL DL and OWL Lite sublanguages of the OWL Web Ontology Language, with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language (RuleML). REWERSE I1 Rule Markup Language is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages, in this case with the SWRL.

This scenario is a contribution from Milan Milanovic.

These transformations are used to produce a UML class diagram from controlled English text using SBVR and Syntax as intermediate layers. Syntax is an original metamodel allowing to describe syntactical, grammatical and semantical properties of an english text. SBVR is a metamodel, obtained from the OMG's specification, for describing semantics of business vocabularies and facts. UML class diagrams allow to express concepts, relations and instances (a conceptual schema). The aim of this scenario is to allow the automatic production of a SBVR model from a syntactical analysis of an english text, then produce a corresponding UML model. The linguistic analysis itself, which may automatically produce a Syntax model from plain text, is outside the scope of this scenario.

The Table to Microsoft Office Excel example describes a transformation from a very basic table representation (similar to the one produced by the JavaSource to Table transformation) to an Excel workbook with one single worksheet containing this table. The transformation is based on a simplified subset of the SpreadsheetML XML dialect which is the one used by Microsoft to import/export Excel workbooks data in XML since the 2003 version of Microsoft Office. This transformation produces an XML file which can be directly open by Excel 2003. This file describes a workbook with the same content (i.e. the same table) that the one of the input Table model.

The Table to SVGBarChart example describes a transformation from a Table model to a SVG file containing several bar chart representations.

This scenario is contributed by Eric Vépa (SODIUS).

The Table to SVGPieChart example describes a transformation from a Table model to a SVG file containing several pie chart representations.

This scenario is contributed by Eric Vépa (SODIUS).

The Table to TabularHTML example describes a transformation from a Table model to an HTML file containing HTML tables.

This scenario is contributed by Eric Vépa (SODIUS).

This transformation presents a basic example where a tree is transformed into a list. This kind of transformation is usually made by an imperative Depth First Traversal algorithm. This scenario is a contribution from Cyril Faure (C-S).

These files provide a case study for model transformation applied to digital logic circuits. Engineers can use various formalisms to represent combinatorial or sequential logic. The most widespread representations for combinatorial logic are truth tables and boolean equations.

In many EDA tools, combinatorial logic is represented in a canonical form using Binary Decision Diagrams (BDD). BDDs are manly used for model checking and logic optimization.

The purpose here is to use model transformation to transform a truth table into a binary decision diagram.

This transformation and associated metamodels is a contribution from Guillaume Savaton, ESEO/TRAME.

The UML2 to Measure example describes measurement on UML2 models, using metrics defined as ATL libraries. This scenario is contributed by Eric Vépa (SODIUS).

The UML to Amble example describes a transformation from an UML model specifying different aspects of a distributed program into an implementation of this distributed program in the Amble programming language.

Amble is a distributed programming language based on Objective Caml. It enables to specify a distributed program in terms of processes that run concurrently. These processes are designed as states machines that are connected to each other by means of networks. Each network specifies a set of channels. The source process of a channel is allowed to write to its target process. An Amble program is composed of a single .ml file that includes the definition of the different process types that are involved in the program, as well as a set of .topo files (one for each considered network) that specifies the topology of the defined networks.

This use case presents a transformation from annotated UML2 activity diagrams to AnyLogic simulation models.

This document illustrates a (simplified) classical transformation example from UML models to Java models that has been implemented in ATL. The UML to Java example describes the transformation of a UML model to a simplified Java model. The Java model holds the information for the creation of Java classes, especially what concerns the structure of these classes, namely the package reference, the attributes and the methods.

This scenario generates a metamodel conforming to KM3 from a UML Class Diagram.

The MOF (Meta Object Facility) is an OMG standard enabling to describe metamodels through common semantics. The UML (Unified Modelling Language) Core standard is the OMG common modelling language. Although, the MOF is primarily designed for metamodel definitions and UML Core for the design of models, the two standards handle very close notions. This example describes a transformation enabling to pass from the UML to the MOF semantics. The transformation is based on the UML Profile for MOF OMG specification.

This ATL scenario presents an implementation of the OMG's ODM specification. This transformation is used to produce an OWL ontology + OWL Individuals from a UML Model + UML Instances.

The UMLActivityDiagram to MSProject example describes a transformation from a loop free UML activity diagram (describing some tasks series) to a MS Project. The transformation is based on a simplified subset of the UML State Machine metamodel. This transformation produces a project defined in conformance to a limited subset of the MSProject metamodel.

The UMLDI to SVG example describes a transformation from a UML diagram, that has its presentation information according to the UML Diagram Interchange standard, to its presentation using the W3C standard SVG (Scalable Vector Graphics), an XMLbased format.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

Introduction: "UML allows for the introduction of custom abstractions using stereotypes and/or profiles. These abstractions can be refined to a lower-level UML description using refinement transformations. Several refinement transformations are provided to refine such abstractions as 'Observer', 'Singleton' and 'Applet'. Refinement transformations are also provided to refine standard UML elements into lower-level structures, such as associations to public attributes and public attributes to encapsulated attributes (with getter and setter methods)."

The CopyModel transformation copies all elements of one model into another model. There are two variants available:

• CopyModel.atl: This version uses ATL refining mode (see the Public2Private transformation and documentation). This means that copying rules are only required for the root model elements. Also, the input and output model are required to have the same meta-model (and repository), since this is required by refinement mode.
• ModelCopy.atl: Another version based on auto-generated, explicit copying rules for each meta-class. Different (yet compatible) meta-models can be used for input and output model. Also, different repositories can be used, e.g. for copying a model from MDR to EMF.

These transformations are used by Bas Graaf to check the conformance of behavioural specifications. These transformations transform a set of UML Sequence Diagrams into a (hierarchical) UML State Machine. The complete generation of a State Machine from a set of scenarios comprises four consecutive model transformations.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations are meant to merge a model with the main model. The MERGE model is merged with the IN model and written to the OUT model. They are currently limited to copying elements that can occur in UML Class Diagrams (including Action Semantics). There are two variants available:

• MergeModel.atl: Based on refinement mode. This means that all models are required to have the same meta-model (and repository), since this is required by refinement mode. Partly optimised for speed by caching intermediate results in OCL helper attributes.
• ModelMerge.atl: Based on auto-generated, explicit copying rules for each meta-class. Different (yet compatible) meta-models (and repositories) can be used for the models. NOTE: This transformation is no longer maintained/used because it is too complex/inefficient compared to its alternative.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations introduce Attributes (with Java initial values) for each Association End. There are two variants available:

• AssociationAttributes.atl: Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.
• Java2AssociationAttributes.atl: Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations introduce accessor Operations/Methods (with Java bodies) for each public Attribute. The public Attributes are then made private. This transformation is also used in refactoring as "Encapsulate Field". There are two variants available:

• Accessors.atl: Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.
• Java2Accessors.atl: Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations introduce the Java infrastructure to implement the "Observer", "Observable" and "subscribe" Stereotypes. Any instances of "Observer" Classes that have a "subscribe" Association to an "Observable" Class, will automatically be subscribed to the "Observable" instance that they are linked to. In addition, all setter Methods of the "Observable" Class will be updated to do a notify as well. An "update" Operation/Method will be introduced for each "Observer" Class, which is configured to invoke any "onXYZChange" Operations, where "XYZ" is the name of the Attribute that is changed. There are two variants available:

• Observer.atl: Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.
• JavaObserver.atl: Uses the java.util.Observer framework. Also uses Java reflection to detect any "onXYZChange" handler methods. This means that "onXYZChange" methods of subclasses will also be detected and without a recompile of the superclass.

This transformation is part of the UML refinement transformations by Dennis Wagelaar.

A simple transformation that adds a static "getInstance" Operation/Method and a static "instance" Attribute to each Class with a "Singleton" Stereotype. Does not prevent direct usage of the constructor. Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations introduce Java Applet infrastructure for each Class with an "Applet" stereotype. There are two variants available:

• Applet.atl: Turns each "Applet" Class into a java.applet.Applet and introduces the "init", "getParameterInfo" and "getAppletInfo" Operations/Methods.
• MIDlet.atl: Turns each "Applet" Class into a javax.microedition.midlet.MIDlet and introduces the "startApp", "pauseApp", "destroyApp", "init", "destroy", "start" and "stop" Operations/Methods. Works on J2ME MIDP 1.0 or up.

These transformations are part of the UML refinement transformations by Dennis Wagelaar.

These transformations replace the OCL types with Java types. There are two variants available:

• DataTypes.atl: Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.
• Java2DataTypes.atl: Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.

This transformation is part of the UML refinement transformations by Dennis Wagelaar.

A simple transformation that wraps the Method body of each Operation with an "asynchronous" Stereotype inside a Thread. Uses java.lang.Thread, which is part of the Java 1.0 API. Works on J2ME MIDP 1.0 as well.

This ATL scenario transforms a UML2 Class Diagram into a UML2 Profile.

The WSDL to R2ML transformation scenario describes a transformation from WSDL (Web Services Description Language) metamodel into a R2ML (REWERSE I1 Markup Language) metamodel. "WSDL enables one to separate the description of the abstract functionality offered by a service from concrete details of a service description such as 'how' and 'where' that functionality is offered". REWERSE I1 Rule Markup Language is a general web rule markup language, that can represent different rule types: integrity, reaction, derivation and production. It is used as pivotal metamodel to enable sharing rules between different rule languages.

This scenario is a contribution from Marko Ribaric.

The XSLT to XQuery example describes a simplified transformation of XSLT code to XQuery code.