atlTransformations/atlTransformations.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<atlTransformations>
	<atlTransformation>
		<shortName>Ant2Maven</shortName>
		<name>Ant to Maven</name>
		<docLink>Ant2Maven/ExampleAnt2Maven[v00.01].pdf</docLink>
		<sourceLink>Ant2Maven/Ant2Maven.zip</sourceLink>
		<description>
	    	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).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>AssertionModification</shortName>
		<name>AssertionModification</name>
		<docLink>AssertionModification/AssertionModification.pdf</docLink>
		<sourceLink>AssertionModification/AssertionModification.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			The purpose of this transformation is to weakening preconditions or strengthening postconditions.
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>ATL2BindingDebugger</shortName>
		<name>ATL to BindingDebugger</name>
		<docLink>ATL2BindingDebugger/README.txt</docLink>
		<sourceLink>ATL2BindingDebugger/ATL2BindingDebugger.zip</sourceLink>
		<description>
			<p>
				The ATL2BindingDebugger ATL transformation adds a debug instruction to each binding in an ATL transformation.
			</p>
			<p>
				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.
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>ATL2Problem</shortName>
		<name>ATL to Problem</name>
		<docLink>ATL2Problem/ExampleATL2Problem[v00.01].pdf</docLink>
		<sourceLink>ATL2Problem/ATL2Problem.zip</sourceLink>
		<description>
			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).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>ATL2Tracer</shortName>
		<name>ATL to Tracer</name>
		<docLink>ATL2Tracer/README.txt</docLink>
		<sourceLink>ATL2Tracer/ATL2Tracer.zip</sourceLink>
		<description>
			<p>
				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.
			</p>
			<p>
				To find more details concerning dealing traceability in ATL, please refer to [1].
			</p>
			<p>
				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.
			</p>
			<p>
				References:
				<ul>
					<li>[1] Jouault, F : Loosely Coupled Traceability for ATL. In: Proceedings of the European Conference on Model Driven Architecture (ECMDA) workshop on traceability, Nuremberg, Germany.</li>
				</ul>
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>BibTeXML2DocBook</shortName>
		<name>BibTeXML to DocBook</name>
		<docLink>BibTeXML2DocBook/ExampleBibTeXML2DocBook[v00.01].pdf</docLink>
		<sourceLink>BibTeXML2DocBook/BibTeXML2DocBook.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Book2Publication</shortName>
		<name>Book to Publication</name>
		<docLink>Book2Publication/ExampleBook2Publication[v00.02].pdf</docLink>
		<sourceLink>Book2Publication/Book2Publication.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>CatalogueModelTransformations</shortName>
		<name>CatalogueModelTransformations</name>
		<docLink>CatalogueModelTransformations/CatalogueModelTransformations.pdf</docLink>
		<sourceLink>CatalogueModelTransformations/CatalogueModelTransformations.zip</sourceLink>
		<description>
			All transformations have been extracted from the catalogue of models transformations: <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf</a>.
			From this catalogue, the following ATL transformations have been created:
			<ul>
				<li>Assertion Modification</li>
				<li>Disaggregation</li>
				<li>Eliminate Redundant Inheritance</li>
				<li>Equivalence of attributes and associations</li>
				<li>Introduce Primary Key</li>
				<li>Introducing an interface</li>
				<li>Making partial role total</li>
				<li>Merging Partial Classes</li>
				<li>Raise Supplier Abstraction Level</li>
				<li>Redundant Class Removable</li>
				<li>Removing a Many Many Association</li>
				<li>Removing An Association Class</li>
				<li>Replace association by foreign key</li>
				<li>Replace inheritance by association</li>
			</ul>
			They were extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a> and <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Class2Relational</shortName>
		<name>Class to Relational</name>
		<docLink>Class2Relational/ExampleClass2Relational[v00.01].pdf</docLink>
		<sourceLink>Class2Relational/Class2Relational.zip</sourceLink>
		<description>
	    	The Class to Relational example describes the simplified transformation of a class schema model to a
      		relational database model.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>CodeCloneTools2SVG</shortName>
		<name>Code Clone Tools to SVG</name>
		<docLink>CodeCloneTools2SVG/CodeCloneTools2SVG.pdf</docLink>
		<sourceLink>CodeCloneTools2SVG/VisualRepCodeClone.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>CPL2SPL</shortName>
		<name>CPL to SPL</name>
		<docLink>CPL2SPL/README.txt</docLink>
		<sourceLink>CPL2SPL/CPL2SPL.zip</sourceLink>
		<description>
			This example handles several aspects of two telephony DSLs: SPL and CPL.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Disaggregation</shortName>
		<name>Disaggregation</name>
		<docLink>Disaggregation/Disaggregation.pdf</docLink>
		<sourceLink>Disaggregation/Disaggregation.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>DSL2EMF</shortName>
		<name>DSL to EMF</name>
		<docLink>DSL2EMF/ExampleDSL2EMF[v00.01].pdf</docLink>
		<sourceLink>DSL2EMF/DSLBridge.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>EliminateRedundantInheritance</shortName>
		<name>EliminateRedundantInheritance</name>
		<docLink>EliminateRedundantInheritance/EliminateRedundantInheritance.pdf</docLink>
		<sourceLink>EliminateRedundantInheritance/EliminateRedundantInheritance.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			"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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>EMF2KM3</shortName>
		<name>EMF2KM3 (Ecore to KM3)</name>
		<docLink>EMF2KM3/README.txt</docLink>
		<sourceLink>EMF2KM3/EMF2KM3.zip</sourceLink>
		<description>
			&lt;p&gt;
    		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.
	  		&lt;/p&gt;
	  		&lt;p&gt;
      		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:
        	&lt;ul&gt;
      		&lt;li&gt;modify EMF2KM3.atl to support desired features,&lt;/li&gt;
      		&lt;li&gt;compile it into EMF2KM3.asm (this is normally automatically performed by the ATL builder),&lt;/li&gt;
      		&lt;li&gt;copy EMF2KM3.asm into org.atl.eclipse.km3 / src / org / atl / eclipse / km3 / resources,&lt;/li&gt;
      		&lt;li&gt;restart Eclipse.&lt;/li&gt;
	  		&lt;/p&gt;			
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>EquivalenceAttributesAssociations</shortName>
		<name>EquivalenceAttributesAssociations</name>
		<docLink>EquivalenceAttributesAssociations/EquivalenceAttributesAssociations.pdf</docLink>
		<sourceLink>EquivalenceAttributesAssociations/EquivalenceAttributesAssociations.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Families2Persons</shortName>
		<name>Families to Persons</name>
		<docLink>http://www.eclipse.org/atl/documentation/old/ATLUseCase_Families2Persons.pdf</docLink>
		<sourceLink>Families2Persons/Families2Persons.zip</sourceLink>
		<description>
			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".
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>FM2BPMN</shortName>
		<name>Feature Models for representing runtime variability in BIS to Business Process Model Notation</name>
		<docLink>http://www.isa.us.es/uploads/tools/fm2bpmn/doc/draft.pdf</docLink>
		<sourceLink>http://www.isa.us.es/uploads/tools/fm2bpmn/transformations/top-down/full/fm2bpmn.atl</sourceLink>
		<description>
			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.
		</description>
		<pubDate/>
	</atlTransformation>
  	<atlTransformation>
		<shortName>GeometricalTransformations</shortName>
		<name>Geometrical Transformations</name>
		<docLink>GeometricalTransformations/ExampleGeometricalTransformations[v00.02].pdf</docLink>
		<sourceLink>GeometricalTransformations/Geometry.zip</sourceLink>
		<description>
	    	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&lt;sup&gt;TM&lt;/sup&gt;, 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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Grafcet2PetriNet</shortName>
		<name>Grafcet to PetriNet</name>
		<docLink>Grafcet2PetriNet/ExampleGrafcet2PetriNet[v00.01].pdf</docLink>
		<sourceLink>Grafcet2PetriNet/Grafcet2PetriNet.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>IEEE1471_2_MoDAF</shortName>
		<name>IEEE1471 to MoDAF</name>
		<docLink>IEEE1471_2_MoDAF/IEEE1471_2_MoDAF.doc</docLink>
		<sourceLink>IEEE1471_2_MoDAF/IEEE1471_2_MoDAF.zip</sourceLink>
		<description>
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/jossic">Albin Jossic</a>.<br />
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>IntroducePrimaryKey</shortName>
		<name>IntroducePrimaryKey</name>
		<docLink>IntroducePrimaryKey/IntroducePrimaryKey.pdf</docLink>
		<sourceLink>IntroducePrimaryKey/IntroducePrimaryKey.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			This is an essential step for implementation of a data model in relational database.
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>IntroducingInterface</shortName>
		<name>IntroducingInterface</name>
		<docLink>IntroducingInterface/IntroducingInterface.pdf</docLink>
		<sourceLink>IntroducingInterface/IntroducingInterface.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Java2Table</shortName>
		<name>Java source to Table</name>
		<docLink>Java2Table/ExampleJavaSource2Table[v00.01].pdf</docLink>
		<sourceLink>Java2Table/Java2Table.zip</sourceLink>
		<description>
			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.).			
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32ATLCopier</shortName>
		<name>KM3 to ATL Copier</name>
		<docLink>KM32ATLCopier/README.txt</docLink>
		<sourceLink>KM32ATLCopier/KM32ATLCopier.zip</sourceLink>
		<description>
    		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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>KM32CONFATL</shortName>
		<name>KM3 to ATL conformance checking transformation</name>
		<docLink>http://www.st.ewi.tudelft.nl/~basgraaf/software/mde/atl/KM32CONFATL/README.txt</docLink>
		<sourceLink>http://www.st.ewi.tudelft.nl/~basgraaf/software/mde/atl/KM32CONFATL/KM32CONFATL.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32DOT</shortName>
		<name>KM3 to DOT</name>
		<docLink>KM32DOT/ExampleKM32DOT[v00.01].pdf</docLink>
		<sourceLink>KM32DOT/KM32DOT.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32EMF</shortName>
		<name>KM32EMF (KM3 to Ecore)</name>
		<docLink>KM32EMF/README.txt</docLink>
		<sourceLink>KM32EMF/KM32EMF.zip</sourceLink>
		<description>
			<p>
				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.
			</p>
	  		<p>
				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:
				<ul>
					<li>modify KM32EMF.atl to support desired features,</li>
					<li>compile it into KM32EMF.asm (this is normally automatically performed by the ATL builder),</li>
					<li>copy KM32EMF.asm into org.atl.eclipse.km3 / src / org / atl / eclipse / km3 / resources,</li>
					<li>restart Eclipse.</li>
				</ul>
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32Measure</shortName>
		<name>KM3 to Measure</name>
		<docLink>KM32Measure/ExampleKM32Measure[v00.02].pdf</docLink>
		<sourceLink>KM32Measure/KM32Measure.zip</sourceLink>
		<description>
			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 <a href="KM32Metrics">KM32Metrics</a>. It is contributed
			by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32Metrics</shortName>
		<name>KM3 to Metrics</name>
		<docLink>KM32Metrics/ExampleKM32Metrics[v00.01].pdf</docLink>
		<sourceLink>KM32Metrics/KM32Metrics.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32OWL</shortName>
		<name>KM3 to OWL</name>
		<docLink>KM32OWL/README.txt</docLink>
		<sourceLink>KM32OWL/KM32OWL.zip</sourceLink>
		<description>
			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
			<a href="http://protege.stanford.edu">(see http://protege.stanford.edu)</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32Problem</shortName>
		<name>KM3 to Problem</name>
		<docLink>KM32Problem/ExampleKM32Problem[v00.01].pdf</docLink>
		<sourceLink>KM32Problem/KM32Problem.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KM32XML</shortName>
		<name>KM3 to XML</name>
		<docLink>KM32XML/readme.txt</docLink>
		<sourceLink>KM32XML/KM32XML.zip</sourceLink>
		<description>
			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. 
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>KMLInjector</shortName>
		<name>KML Injector</name>
		<docLink>KMLInjector/ExampleKMLInjector[v00.01].pdf</docLink>
		<sourceLink>KMLInjector/KMLInjector.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>ListMetamodelRefactoring</shortName>
		<name>List Metamodel Refactoring</name>
		<docLink>http://www.eclipse.org/atl/documentation/basicExamples_Patterns/article.php?file=ListMetamodelRefactoring/index.html</docLink>
		<sourceLink>ListMetamodelRefactoring/ListMetamodelRefactoring.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Make2Ant</shortName>
		<name>Make to Ant</name>
		<docLink>Make2Ant/ExampleMake2Ant[v00.01].pdf</docLink>
		<sourceLink>Make2Ant/Make2Ant.zip</sourceLink>
		<description>
	    	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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>MakePartialRoleTotal</shortName>
		<name>MakePartialRoleTotal</name>
		<sourceLink>MakePartialRoleTotal/MakePartialRoleTotal.zip</sourceLink>
		<docLink>MakePartialRoleTotal/MakingPartialRoleTotal(a).pdf</docLink>
		<docLink>MakePartialRoleTotal/MakingPartialRoleTotal(b).pdf</docLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			Total associations are generally easier to implement and manage than partial associations.
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Maven2Ant</shortName>
		<name>Maven to Ant</name>
		<docLink>Maven2Ant/ExampleMaven2Ant[v00.01].pdf</docLink>
		<sourceLink>Maven2Ant/Maven2Ant.zip</sourceLink>
		<description>
			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.			
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Measure2Table</shortName>
		<name>Measure to Table</name>
		<docLink>Measure2Table/ExampleMeasure2Table[v00.01].pdf</docLink>
		<sourceLink>Measure2Table/Measure2Table.zip</sourceLink>
		<description>
			The Measure2Table project is used to creates generic tables from a measure model.
			This scenario is used by the scenario <a href="ModelMeasurement">Model Measurement</a>.
			It is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Measure2XHTML</shortName>
		<name>Measure to XHTML</name>
		<docLink>Measure2XHTML/ExampleMeasure2XHTML[v00.01].pdf</docLink>
		<sourceLink>Measure2XHTML/Measure2XHTML.zip</sourceLink>
		<description>
			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 <a href="ModelMeasurement">Model Measurement</a>.
			It is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MeasuringModelRepositories</shortName>
		<name>Measuring Model Repositories</name>
		<docLink>MeasuringModelRepositories/ExampleMeasuringModelRepositories[v00.01].pdf</docLink>
		<sourceLink>MeasuringModelRepositories/MeasuringModelRepositories.zip</sourceLink>
		<description>
			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).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>MergingPartialClasses</shortName>
		<name>MergingPartialClasses</name>
		<docLink>MergingPartialClasses/MergingPartialClasses.pdf</docLink>
		<sourceLink>MergingPartialClasses/MergingPartialClasses.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			The purpose of this transformation is to merge the class link by a association one-one.
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>METAH2ACME</shortName>
		<name>MetaH to ACME</name>
		<docLink>METAH2ACME/METAH2ACME.pdf</docLink>
		<sourceLink>METAH2ACME/METAH2ACME.zip</sourceLink>
		<description>
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.<br />
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MDL2GMF</shortName>
		<name>MDL to GMF</name>
		<docLink>http://www.eclipse.org/atl/usecases/MDL2GMF/</docLink>
		<sourceLink>MDL2GMF/org.eclipse.m2m.atl.mdl2gmf.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>ModelMeasurement</shortName>
		<name>Models Measurement</name>
		<docLink>http://www.eclipse.org/atl/usecases/ModelsMeasurement/</docLink>
		<sourceLink>ModelMeasurement/ModelsMeasurement.zip</sourceLink>
		<description>
			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 (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MOF2UML</shortName>
		<name>MOF to UML</name>
		<docLink>MOF2UML/ExampleMOF2UML[v00.01].pdf</docLink>
		<sourceLink>MOF2UML/UML2MOF.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Monitor2Semaphore</shortName>
		<name>Monitor to Semaphore</name>
		<docLink>Monitor2Semaphore/ExampleMonitor2Semaphore[v00.01].pdf</docLink>
		<sourceLink>Monitor2Semaphore/Monitor2Semaphore.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MSOfficeExcelExtractor</shortName>
		<name>Microsoft Office Excel Extractor</name>
		<docLink>MSOfficeExcelExtractor/ExampleMicrosoftOfficeExcelExtractor[v00.01].pdf</docLink>
		<sourceLink>MSOfficeExcelExtractor/MicrosoftOfficeExcelExtractor.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MSOfficeExcelInjector</shortName>
		<name>Microsoft Office Excel Injector</name>
		<docLink>MSOfficeExcelInjector/ExampleMicrosoftOfficeExcelInjector[v00.01].pdf</docLink>
		<sourceLink>MSOfficeExcelInjector/MicrosoftOfficeExcelInjector.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MSOfficeExcel2SoftwareQualityControl</shortName>
		<name>Microsoft Office Excel to Software Quality Control</name>
		<docLink>MSOfficeExcel2SoftwareQualityControl/ExampleMicrosoftOfficeExcel2SoftwareQualityControl[v00.01].pdf</docLink>
		<sourceLink>MSOfficeExcel2SoftwareQualityControl/MicrosoftOfficeExcel2SoftwareQualityControl.zip</sourceLink>
		<description>
		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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>MySQL2KM3</shortName>
		<name>MySQL to KM3</name>
		<docLink>MySQL2KM3/ExampleMySQL2KM3[v00.01].pdf</docLink>
		<sourceLink>MySQL2KM3/MySQL2KM3.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>OBL2UML</shortName>
		<name>OpenBlueLab to UML</name>
		<docLink>http://www.openbluelab.org/content/Bookmark.process@@docid=20070607144710186_315843775601&amp;action=read&amp;target=CommunityZone</docLink>
		<sourceLink>http://forge.openbluelab.org/gf/project/omf/frs/</sourceLink>
		<description>
			<p>
			<a href="http://www.openbluelab.org">OpenBlueLab</a> project's ambition is to provide an application which you can adapt easily by just updating UML models 
			contained in the <a href="http://www.openbluelab.org">OpenBlueLab</a> download,  without writing any line of code. <a href="http://www.openbluelab.org">OpenBlueLab</a>
			use as input XMI file but too OBL file conforms to our specialized metamodel used to generate a particular editor,  <a href="http://forge.openbluelab.org/gf/project/omf/">OpenBlueLab Developer Studio</a>.
			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.
			</p>
			<p>This scenario is a contribution from Benjamin Chevallereau (<a href="http://www.openbluelab.org">OpenBlueLab</a>).</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>OCL2R2ML</shortName> 
		<name>OCL to R2ML</name> 
		<docLink>OCL2R2ML/README.txt</docLink> 
		<sourceLink>OCL2R2ML/OCL2R2ML.zip</sourceLink> 
		<description>
			<p align="justify">
			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.
			</p>
			<p>This scenario is a contribution from <a href="http://milan.milanovic.org/">Milan Milanovic</a>.</p>
		</description>
		<pubDate />
	</atlTransformation>
	<atlTransformation>
		<shortName>OCL2SWRL</shortName>
		<name>OCL to SWRL</name>
		<docLink>OCL2SWRL/README.txt</docLink>
		<sourceLink>OCL2SWRL/OCL2SWRL.zip</sourceLink>
		<description>
			<p align="justify">
			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).
			</p>
			<p>This scenario is a contribution from <a href="http://milan.milanovic.org/">Milan Milanovic</a>.</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>PathExp2PetriNet</shortName>
		<name>PathExp to PetriNet</name>
		<docLink>PathExp2PetriNet/ExamplePathExp2PetriNet[v00.01].pdf</docLink>
		<sourceLink>PathExp2PetriNet/PathExp2PetriNet.zip</sourceLink>
		<description>
			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).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Port</shortName>
		<name>Port</name>
		<docLink>http://www.eclipse.org/atl/documentation/basicExamples_Patterns/article.php?file=Port/index.html</docLink>
		<sourceLink>Port/Port.zip</sourceLink>
		<description>
			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
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Public2Private</shortName>
		<name>Public to Private</name>
		<docLink>Public2Private/README.txt</docLink>
		<sourceLink>Public2Private/Public2Private.zip</sourceLink>
		<description>
			&lt;p&gt;
			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.
			&lt;/p&gt;
			&lt;p&gt;
			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: &lt;a href="Public2Private/PetriNet.png">PetriNet.png&lt;/a&gt; and &lt;a href="Public2Private/PetriNet-Privatized.png">PetriNet-Privatized.png&lt;/a&gt;.
			Additional source models may be created using Poseidon (http://www.gentleware.com/).
			&lt;/p&gt;
			&lt;p&gt;
			References:
			&lt;ul&gt;
				&lt;li&gt;[1] &lt;a href="http://www.sciences.univ-nantes.fr/lina/atl/bibliography/MTIP05">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&lt;/a&gt;&lt;/li&gt;
			&lt;/ul&gt;
			&lt;/p&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>QVT2ATLVM</shortName>
		<name>QVT to ATL Virtual Machine Compiler</name>
		<docLink>../usecases/QVT2ATLVM/</docLink>
		<sourceLink>QVT2ATLVM/QVT2ATLVM.zip</sourceLink>
		<description>
			<p>
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).
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>R2ML2OCL</shortName> 
		<name>R2ML to OCL</name> 
		<docLink>R2ML2OCL/README.txt</docLink> 
		<sourceLink>R2ML2OCL/R2ML2OCL.zip</sourceLink> 
		<description>
			<p align="justify">
			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.
			</p>
			<p>This scenario is a contribution from <a href="http://milan.milanovic.org/">Milan Milanovic</a>.</p>
		</description> 
		<pubDate /> 
	</atlTransformation>
	<atlTransformation>
		<shortName>R2ML2SWRL</shortName> 
		<name>R2ML to SWRL</name> 
		<docLink>R2ML2SWRL/README.txt</docLink> 
		<sourceLink>R2ML2SWRL/R2ML2SWRL.zip</sourceLink> 
		<description>
			<p align="justify">
			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.
			</p>
			<p>This scenario is a contribution from <a href="http://milan.milanovic.org/">Milan Milanovic</a>.</p>
		</description> 
		<pubDate /> 
	</atlTransformation>
	<atlTransformation>
		<shortName>RaiseSupplierAbstractionLevel</shortName>
		<name>RaiseSupplierAbstractionLevel</name>
		<docLink>RaiseSupplierAbstractionLevel/RaiseSupplierAbstractionLevel.pdf</docLink>
		<sourceLink>RaiseSupplierAbstractionLevel/RaiseSupplierAbstractionLevel.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>RedundantClassRemovable</shortName>
		<name>RedundantClassRemovable</name>
		<docLink>RedundantClassRemovable/RedundantClassRemovable.pdf</docLink>
		<sourceLink>RedundantClassRemovable/RedundantClassRemovable.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>RemovingAssociationClass</shortName>
		<name>RemovingAssociationClass</name>
		<docLink>RemovingAssociationClass/RemovingAssociationClass.pdf</docLink>
		<sourceLink>RemovingAssociationClass/RemovingAssociationClass.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			The purpose of this transformation is: "association classes cannot be represented directly in many object-oriented programming languages."
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>RemovingManyManyAssociation</shortName>
		<name>RemovingManyManyAssociation</name>
		<docLink>RemovingManyManyAssociation/RemovingManyManyAssociation.pdf</docLink>
		<sourceLink>RemovingManyManyAssociation/RemovingManyManyAssociation.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/simon">Eric Simon</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>ReplaceAssociationByForeignKey</shortName>
		<name>ReplaceAssociationByForeignKey</name>
		<docLink>ReplaceAssociationByForeignKey/ReplaceAssociationByForeignKey.pdf</docLink>
		<sourceLink>ReplaceAssociationByForeignKey/ReplaceAssociationByForeignKey.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			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 <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>ReplaceInheritanceByAssociation</shortName>
		<name>ReplaceInheritanceByAssociation</name>
		<docLink>ReplaceInheritanceByAssociation/ReplaceInheritanceByAssociation.pdf</docLink>
		<sourceLink>ReplaceInheritanceByAssociation/ReplaceInheritanceByAssociation.zip</sourceLink>
		<description>
			This example is extract from <a href="http://www.dcs.kcl.ac.uk/staff/kcl/tcat.pdf">Catalogue of Model Transformations by K. Lano</a>.
			This transformation replaces an inheritance relationship between two classes by an association between the classes.
			This example was extracted by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/baudry">Julien Baudry</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>RSS2ATOM</shortName>
		<name>RSS to ATOM</name>
		<docLink>RSS2ATOM/RSS2ATOM.pdf</docLink>
		<sourceLink>RSS2ATOM/RSS2ATOM.zip</sourceLink>
		<description>
			RSS is a format for syndicating news and the content of news-like sites.<br />
			Atom is an XML-based file format intended to allow lists of information, known as "feeds", to be synchronised between publishers and consumers.<br />
			RSS to ATOM was produced by <a href="http://www.sciences.univ-nantes.fr/lina/atl/contrib/srour">Youssef Srour</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>SideEffect</shortName>
		<name>Side Effect</name>
		<docLink>http://www.eclipse.org/atl/documentation/basicExamples_Patterns/article.php?file=SideEffect/index.html</docLink>
		<sourceLink>SideEffect/SideEffect.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>SimpleClass2SimpleRDBMS</shortName>
		<name>Simple Class to Simple RDBMS</name>
		<docLink>SimpleClass2SimpleRDBMS/README.txt</docLink>
		<sourceLink>SimpleClass2SimpleRDBMS/SimpleClass2SimpleRDBMS.zip</sourceLink>
		<description>
			&lt;p&gt;
			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/.
			&lt;/p&gt;
			&lt;p&gt;
			Two versions of the SimpleClass2SimpleRDBMS transformation have been developed:
			&lt;ul&gt;
				&lt;li&gt;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.
				&lt;/li&gt;
				&lt;li&gt;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.
				&lt;/li&gt;
			&lt;/ul&gt;
			&lt;/p&gt;
			&lt;p&gt;
			References:
			&lt;ul&gt;
				&lt;li&gt;[1] &lt;a href="http://sosym.dcs.kcl.ac.uk/events/mtip05/submissions/jouault_kurtev__transforming_models_with_atl.pdf">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
				&lt;/li&gt;
			&lt;/ul&gt;
			&lt;/p&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>SimplePDL2Tina</shortName>
		<name>SimplePDL2Tina: models verification through Petri nets</name>
		<docLink>http://www.eclipse.org/atl/usecases/SimplePDL2Tina/</docLink>
		<sourceLink>http://combemale.perso.enseeiht.fr/atlzoo/SimplePDL2TinaZoo.zip</sourceLink>
		<description>
	    	These transformations are part of a 
			<a href="http://www.combemale.fr/wiki/doku.php?id=private:enseignement:metamodeling">Course</a>
			about metamodeling, models transformation and verification. 
			These transformations introduce a property-driven approach to validate models through a translational semantics to Petri nets.
		</description>
		<pubDate>30/01/07</pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>SoftwareQualityControl2Bugzilla</shortName>
		<name>Software Quality Control to Bugzilla</name>
		<docLink>SoftwareQualityControl2Bugzilla/ExampleSoftwareQualityControl2Bugzilla[v00.01].pdf</docLink>
		<sourceLink>SoftwareQualityControl2Bugzilla/SoftwareQualityControl2Bugzilla.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>SoftwareQualityControl2MantisBT</shortName>
		<name>Software Quality Control to Mantis Bug Tracker</name>
		<docLink>SoftwareQualityControl2MantisBT/ExampleSoftwareQualityControl2MantisBugTracker[v00.01].pdf</docLink>
		<sourceLink>SoftwareQualityControl2MantisBT/SoftwareQualityControl2MantisBugTracker.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>SSL2SDL</shortName>
		<name>SSL to SDL</name>
		<docLink>SSL2SDL/ssl2sdl.pdf</docLink>
		<sourceLink>SSL2SDL/SSL2SDL.zip</sourceLink>
		<description>
			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.
			<br /><br />
			This transformation and associated metamodels is a contribution from 
			Irina Dumitrascu and Natalia Rebeja , <a href="http://www.soluta.net">Soluta.Net</a>.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>SWRL2R2ML</shortName> 
		<name>SWRL to R2ML</name> 
		<docLink>SWRL2R2ML/README.txt</docLink> 
		<sourceLink>SWRL2R2ML/SWRL2R2ML.zip</sourceLink> 
		<description>
			<p align="justify">
			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.
			</p>
			<p>This scenario is a contribution from <a href="http://milan.milanovic.org/">Milan Milanovic</a>.</p>
		</description> 
		<pubDate /> 
	</atlTransformation>
	<atlTransformation>
		<shortName>Syntax2SBVR2UML</shortName>
		<name>Syntax to SBVR to UML</name>
		<docLink>../usecases/Syntax2SBVR2UML/</docLink>
		<sourceLink>Syntax2SBVR2UML/Syntax2SBVR2UML.zip</sourceLink>
		<description>
			<p align="justify">
			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.
			</p>
		</description>
		<pubDate/>
	</atlTransformation>
  	<atlTransformation>
		<shortName>Table2MSOfficeExcel</shortName>
		<name>Table to Microsoft Office Excel</name>
		<docLink>Table2MSOfficeExcel/ExampleTable2MicrosoftOfficeExcel[v00.01].pdf</docLink>
		<sourceLink>Table2MSOfficeExcel/Table2MicrosoftOfficeExcel.zip</sourceLink>
		<description>
			The Table to Microsoft Office Excel example describes a transformation from a very basic table representation (similar to the one produced by the &lt;a href="#Java2Table">JavaSource to Table&lt;/a&gt; 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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Table2SVGBarChart</shortName>
		<name>Table2SVGBarChart</name>
		<docLink>Table2SVGBarChart/ExampleTable2SVGBarChart[v00.05].pdf</docLink>
		<sourceLink>Table2SVGBarChart/Table2SVGBarChart.zip</sourceLink>
		<description>
			The Table to SVGBarChart example describes a transformation from a Table model to a SVG
			file containing several bar chart representations.<br />
			This scenario is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Table2SVGPieChart</shortName>
		<name>Table2SVGPieChart</name>
		<docLink>Table2SVGPieChart/ExampleTable2SVGPieChart[v00.05].pdf</docLink>
		<sourceLink>Table2SVGPieChart/Table2SVGPieChart.zip</sourceLink>
		<description>
			The Table to SVGPieChart example describes a transformation from a Table model to a SVG
			file containing several pie chart representations.<br />
			This scenario is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Table2TabularHTML</shortName>
		<name>Table2TabularHTML</name>
		<docLink>Table2TabularHTML/ExampleTable2TabularHTML[v00.05].pdf</docLink>
		<sourceLink>Table2TabularHTML/Table2TabularHTML.zip</sourceLink>
		<description>
			The Table to TabularHTML example describes a transformation from a Table model to an
			HTML file containing HTML tables.<br />
			This scenario is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>Tree2List</shortName>
		<name>Tree to List</name>
		<docLink>../basicExamples_Patterns/Tree2List/</docLink>
		<sourceLink>Tree2List/Tree2List.zip</sourceLink>
		<description>
			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 (<a href="http://www.c-s.fr/">C-S</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>TT2BDD</shortName>
		<name>Truth Tables to Binary Decision Diagrams</name>
		<docLink>TT2BDD/README</docLink>
		<sourceLink>TT2BDD/TT2BDD.zip</sourceLink>
		<description>
			<p>
				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.
			</p>
			<p>
				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.
			</p>
			<p>
				The purpose here is to use model transformation to transform a truth table into a binary decision diagram.
			</p>
			<p>
				This transformation and associated metamodels is a contribution from Guillaume Savaton, ESEO/TRAME.
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>UML22Measure</shortName>
		<name>UML2 to Measure</name>
		<docLink>UML22Measure/ExampleUML22Measure[v00.02].pdf</docLink>
		<sourceLink>UML22Measure/UML22Measure.zip</sourceLink>
		<description>
			The UML2 to Measure example describes measurement on UML2 models, using metrics defined as ATL libraries.
			This scenario is contributed by Eric Vépa (<a href="http://www.sodius.com">SODIUS</a>).
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UML2Amble</shortName>
		<name>UML to Amble</name>
		<docLink>UML2Amble/ExampleUML2Amble[v00.01].pdf</docLink>
		<sourceLink>UML2Amble/UML2Amble.zip</sourceLink>
		<description>
			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.&lt;br /&gt;&lt;br /&gt;
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UML2AnyLogic</shortName>
		<name>UML to AnyLogic</name>
		<docLink>http://www.eclipse.org/atl/usecases/UML2AnyLogic/</docLink>
		<sourceLink>UML2AnyLogic/UML2AnyLogic.zip</sourceLink>
		<description>
			This use case presents a transformation from annotated UML2 activity diagrams to AnyLogic simulation models.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UML2Java</shortName>
		<name>UML to Java</name>
		<docLink>UML2Java/ExampleUML2Java[v00.01].pdf</docLink>
		<sourceLink>UML2Java/UML2Java.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UML2KM3</shortName>
		<name>UML Class Diagram to KM3</name>
		<docLink>http://www.eclipse.org/atl/usecases/UML2MOF/</docLink>
		<sourceLink>UML2KM3/UML2KM3.zip</sourceLink>
		<description>
			This scenario generates a metamodel conforming to KM3 from a UML Class Diagram.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UML2MOF</shortName>
		<name>UML to MOF</name>
		<docLink>UML2MOF/ExampleUML2MOF[v00.01].pdf</docLink>
		<sourceLink>UML2MOF/UML2MOF.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>UML2OWL</shortName>
		<name>UML to OWL</name>
		<docLink>UML2OWL/README.txt</docLink>
		<sourceLink>UML2OWL/UML2OWL.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLActivityDiagram2MSProject</shortName>
		<name>UML Activity Diagram to MSProject</name>
		<docLink>UMLActivityDiagram2MSProject/ExampleUmlActivityDiagram2MSProject[v00.01].pdf</docLink>
		<sourceLink>UMLActivityDiagram2MSProject/UmlActivityDiagram2MSProject.zip</sourceLink>
		<description>
			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.			
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLDI2SVG</shortName>
		<name>UMLDI to SVG</name>
		<docLink>UMLDI2SVG/UMLDI2SVG[0.04].pdf</docLink>
		<sourceLink>UMLDI2SVG/UMLDI2SVG.zip</sourceLink>
		<description>
			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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLCopyModel</shortName>
		<name>UML CopyModel, ModelCopy</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#copymodel_modelcopy</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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)."
			&lt;/p&gt;
			&lt;p&gt;
			The CopyModel transformation copies all elements of one model into another model.
			There are two variants available:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/CopyModel.atl?view=markup">CopyModel.atl&lt;/a&gt;:&lt;/b&gt;
			This version uses ATL refining mode (see the &lt;a href="#Public2Private">Public2Private&lt;/a&gt; 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.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/ModelCopy.atl?view=markup">ModelCopy.atl&lt;/a&gt;:&lt;/b&gt;
			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.
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>UMLSD2STMD</shortName>
		<name>UML Sequence Diagrams to Statechart Diagram</name>
		<docLink>http://www.st.ewi.tudelft.nl/~basgraaf/software/mde/atl/UMLSD2STMD/README.txt</docLink>
		<sourceLink>http://www.st.ewi.tudelft.nl/~basgraaf/software/mde/atl/UMLSD2STMD/UMLSD2STMD.zip</sourceLink>
		<description>
			These transformations are used by <a href="http://www.st.ewi.tudelft.nl/~basgraaf">Bas Graaf</a> 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.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLMergeModel</shortName>
		<name>UML MergeModel, ModelMerge</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#mergemodel_modelmerge</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/MergeModel.atl?view=markup">MergeModel.atl&lt;/a&gt;:&lt;/b&gt;
			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.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/ModelMerge.atl?view=markup">ModelMerge.atl&lt;/a&gt;:&lt;/b&gt; 
			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.&lt;/li&gt;
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLAssociationAttributes</shortName>
		<name>UML AssociationAttributes, Java2AssociationAttributes</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#associationattributes_java2associationattributes</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			These transformations introduce Attributes (with Java initial values) for each Association End. There are two variants available:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/AssociationAttributes.atl?view=markup">AssociationAttributes.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Java2AssociationAttributes.atl?view=markup">Java2AssociationAttributes.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.&lt;/li&gt;
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLAccessors</shortName>
		<name>UML Accessors, Java2Accessors</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#accessors_java2accessors</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Accessors.atl?view=markup">Accessors.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Java2Accessors.atl?view=markup">Java2Accessors.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.&lt;/li&gt;
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLObserver</shortName>
		<name>UML Observer, JavaObserver</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#observer_javaobserver</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Observer.atl?view=markup">Observer.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/JavaObserver.atl?view=markup">JavaObserver.atl&lt;/a&gt;:&lt;/b&gt; 
			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.&lt;/li&gt;
			&lt;/ul&gt;			
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLSingleton</shortName>
		<name>UML Singleton</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#singleton</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
	    	&lt;p&gt;
			This transformation is part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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.
			&lt;/p&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLApplet</shortName>
		<name>UML Applet, MIDlet</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#applet_midlet</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			These transformations introduce Java Applet infrastructure for each Class with an "Applet" stereotype. There are two variants available:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Applet.atl?view=markup">Applet.atl&lt;/a&gt;:&lt;/b&gt; 
			Turns each "Applet" Class into a java.applet.Applet and introduces the "init", "getParameterInfo" and "getAppletInfo" Operations/Methods.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/MIDlet.atl?view=markup">MIDlet.atl&lt;/a&gt;:&lt;/b&gt; 
			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.&lt;/li&gt;
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>UMLDataTypes</shortName>
		<name>UML DataTypes, Java2DataTypes</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#datatypes_java2datatypes</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
			&lt;p&gt;
			These transformations are part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			 These transformations replace the OCL types with Java types. There are two variants available:
			&lt;/p&gt;
			&lt;ul&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/DataTypes.atl?view=markup">DataTypes.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses strict Java 1 API. Works on J2ME MIDP 1.0 as well.&lt;/li&gt;
			&lt;li&gt;&lt;b&gt;&lt;a href="http://ssel.vub.ac.be/viewcvs/viewcvs.py/UML1CaseStudies/uml1cs-transformations/Java2DataTypes.atl?view=markup">Java2DataTypes.atl&lt;/a&gt;:&lt;/b&gt; 
			Uses the Java 2 Collections framework. Works on J2ME PP 1.0 as well.&lt;/li&gt;
			&lt;/ul&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLAsyncMethods</shortName>
		<name>UML AsyncMethods</name>
		<docLink>http://ssel.vub.ac.be/ssel/research:mdd:casestudies#asyncmethods</docLink>
		<sourceLink>http://ssel.vub.ac.be/viewcvs/viewcvs.py/svn-gen/UML1CaseStudies/uml1cs-transformations/</sourceLink>
		<description>
	    	&lt;p&gt;
			This transformation is part of  the &lt;a href="http://ssel.vub.ac.be/ssel/research:mdd:casestudies">UML refinement transformations&lt;/a&gt; by &lt;a href="http://ssel.vub.ac.be/ssel/about:members:denniswagelaar">Dennis Wagelaar&lt;/a&gt;.
			&lt;/p&gt;
			&lt;p&gt;
			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.
			&lt;/p&gt;
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>UMLCD2UMLProfile</shortName>
		<name>UML Class Diagram to UML Profile</name>
		<docLink>UMLCD2UMLProfile/README.txt</docLink>
		<sourceLink>UMLCD2UMLProfile/UMLClassDiagram_to_UMLProfile_v0.1.zip</sourceLink>
		<description>
			This ATL scenario transforms a UML2 Class Diagram into a UML2 Profile.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
	<atlTransformation>
		<shortName>WSDL2R2ML</shortName>
		<name>WSDL to R2ML</name>
		<docLink>WSDL2R2ML/README.txt</docLink>
		<sourceLink>WSDL2R2ML/WSDL2R2ML.zip</sourceLink>
		<description>
			<p align="justify">
			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.
			</p>
			<p>
				This scenario is a contribution from Marko Ribaric.
			</p>
		</description>
		<pubDate></pubDate>
	</atlTransformation>
  	<atlTransformation>
		<shortName>XSLT2XQuery</shortName>
		<name>XSLT to XQuery</name>
		<docLink>XSLT2XQuery/ExampleXSLT2XQuery[v00.01].pdf</docLink>
		<sourceLink>XSLT2XQuery/XSLT2XQuery.zip</sourceLink>
		<description>
			The XSLT to XQuery example describes a simplified transformation of XSLT code to XQuery code.
		</description>
		<pubDate></pubDate>
	</atlTransformation>
</atlTransformations>