Home » Archived » M2M (model-to-model transformation) » [ATL] ATLTransformations
| [ATL] ATLTransformations [message #77534] |
Wed, 26 March 2008 18:27  |
Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hello,
I'm trying to execute a transformation programmatically through the
ATLTransformations class. I've modified that class to lauch the
Public2Private example, but I didn't have success.
Thanks for any help.
The code is:
package atl;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.util.*;
import javax.jmi.reflect.*;
import org.atl.eclipse.engine.*;
import org.atl.engine.extractors.*;
import org.atl.engine.extractors.ebnf.*;
import org.atl.engine.injectors.ebnf.*;
import org.atl.engine.extractors.xml.*;
import org.atl.engine.injectors.xml.*;
import org.atl.engine.repositories.emf4atl.*;
import org.atl.engine.vm.nativelib.*;
import org.eclipse.core.runtime.*;
import org.atl.engine.repositories.mdr4atl.*;
import org.atl.engine.vm.*;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.DefaultHandler;
/**
* Main class for running ATL transformations programatically (template)
* TODO: Add support for running AM3 Ant tasks
* @author Milan Milanovic (milan [at] milanovic.org)
* @version 2.3
*/
public class ATLTransformations {
// Stop on error in EBNF Injection
private final static boolean stopOnError = !false;
// Relative location of transformations
String transformationsLocation = "";
// Relative location of metamodels
String transformationsMetamodels = "";
// URL's to compiled ATL transformations (an example of OneMM to OtherMM
transformation)
private URL OneMM2OtherMMurl =
ATLTransformations.class.getResource("Public2Private.asm");
// Add here URL's to your other compiled transformations...
// TCS specific (MM is pseudoname for some your metamodel which is used
for TCS injection/extraction)
//private URL MM_tcs =
ATLTransformations.class.getResource("MOF-1.4.xmi");
//private URL TCS = ATLTransformations.class.getResource("TCS.xmi"); //
uses MDR (change to .ecore for EMF)
// MDR model handler
private AtlModelHandler mdramh = null;
// EMF model handler
private AtlModelHandler emfamh = null;
// MDR meta-metamodels
private ASMModel oneMM_MDR = null;
private ASMModel otherMM_MDR = null;
private ASMModel xmlMDRmm = null; // XML metamodel is needed because of
XML injection/extraction
// Add here objects for you metamodels (MDR - MOF-1.4)...
// For TCS (MDR) support
//private ASMModel tcsMDRmm = null;
//private ASMModel mmTcsMDRmm = null;
// Used for keeping metamodel names
Map MDRMetaModels = new HashMap();
// EMF meta-metamodels
private ASMModel oneMM_EMF = null;
private ASMModel otherMM_EMF = null;
private ASMModel xmlEMFmm = null;
// Add here objects for you metamodels (EMF - Ecore)
// For TCS (EMF) support
//private ASMModel tcsEMFmm = null;
//private ASMModel mmTcsEMFmm = null;
// General meta-models
private ASMModel pbmm = null;
// Instance of ATLTransformations class (Singleton)
private static ATLTransformations atlTransformations = null;
// Markers for Problem metamodel
private MarkerMaker markerMaker;
// Constructor
public ATLTransformations() {
initMDR(); // Initialize MDR based metamodels
//initEMF(); // Initialize EMF based metamodels - if needed
} // -- end of constructor
//////////////////////////////////////////////////////////// /////////////////////////////////
//// General ATL transformation initialization with domain metamodels
specific initialization
//////////////////////////////////////////////////////////// /////////////////////////////////
/**
* Initialize MDR model handler and MOF based metamodels
*/
private void initMDR() {
if(mdramh == null) { // if MDR is not initialized
// Initialize MDR model handler
mdramh = getDefaultHandler("MDR");
// URL's to MOF-1.4 (XMI) metamodels
URL onemmurl = ATLTransformations.class.getResource("UMLDI.xmi");
URL xmlmmurl = ATLTransformations.class.getResource("xml.xmi");
URL othermmurl = ATLTransformations.class.getResource("UMLDI.xmi");
// Add here URL's to your metamodels (MDR - MOF-1.4)...
try {
// Get metamodels
oneMM_MDR = mdramh.loadModel("UMLDI", mdramh.getMof(),
onemmurl.openStream()); // ONE MM
xmlMDRmm = mdramh.loadModel("xml", mdramh.getMof(),
xmlmmurl.openStream()); // XML MM
otherMM_MDR = mdramh.loadModel("UMLDI", mdramh.getMof(),
othermmurl.openStream()); // Other MM
// Load your metamodels here...
// Only for TCS output!!
//tcsMDRmm = mdramh.loadModel("TCS", mdramh.getMof(),
TCS.openStream()); // TCS MM
//mmTcsMDRmm = mdramh.loadModel("MOF-1.4", tcsMDRmm,
MM_tcs.openStream()); // MM-TCS MM
// Put metamodels in map for easy lookup
MDRMetaModels.put("OneMM", oneMM_MDR);
MDRMetaModels.put("XML", xmlMDRmm);
MDRMetaModels.put("OtherMM", otherMM_MDR);
//MDRMetaModels.put("TCS", tcsMDRmm);
//MDRMetaModels.put("MOF-1.4", mmTcsMDRmm);
} catch (IOException e) {
e.printStackTrace();
}
}
} // -- end of initMDR
/**
* Initialize EMF model handler and Ecore based metamodels
*/
private void initEMF() {
if(emfamh == null) { // if EMF is not initialized
// Initialize EMF model handler
emfamh = AtlModelHandler.getDefault(AtlModelHandler.AMH_EMF);
// URL's to Ecore (XMI) metamodels
URL onemmurl =
ATLTransformations.class.getResource(transformationsMetamode ls +
"oneMM/oneMM.ecore");
URL xmlmmurl =
ATLTransformations.class.getResource(transformationsMetamode ls +
"xml/xml.ecore");
URL othermmurl =
ATLTransformations.class.getResource(transformationsMetamode ls +
"otherMM/otherMM.ecore");
// Add here URL's to your metamodels (EMF - Ecore)...
try {
// Get metamodels
oneMM_EMF = emfamh.loadModel("OneMM", emfamh.getMof(),
onemmurl.openStream());
xmlEMFmm = emfamh.loadModel("XML", emfamh.getMof(),
xmlmmurl.openStream());
otherMM_EMF = emfamh.loadModel("OtherMM", emfamh.getMof(),
othermmurl.openStream());
// Load your metamodels here...
// Only for TCS output!!
//tcsEMFmm = emfamh.loadModel("TCS", emfamh.getMof(),
TCS.openStream()); // TCS MM
//mmTcsEMFmm = emfamh.loadModel("MM.tcs", tcsEMFmm,
MM_tcs.openStream()); // MM-TCS MM
} catch (IOException e) {
e.printStackTrace();
}
}
pbmm = emfamh.getBuiltInMetaModel("Problem");
markerMaker = new MarkerMaker();
} // -- end of initEMF
/**
* Returns default model handler (currently supported MDR and EMF)
* @param repository String which represents model handler
* @return default repository for input (EMF or MDR)
*/
private AtlModelHandler getDefaultHandler(String repository) {
AtlModelHandler amh = null;
try {
amh = AtlModelHandler.getDefault(repository);
} catch (Throwable e) {
if ("MDR".equals(repository)) {
AtlModelHandler.registerDefaultHandler("MDR", new
AtlMDRModelHandler()); // register
amh = AtlModelHandler.getDefault(repository);
} else {
throw new RuntimeException(e);
}
}
return amh;
} // -- end of getDefaultHandler
/**
* Returns static instance of ATLTransformations class (Singleton)
* @return default repository for input (EMF or MDR)
*/
public static ATLTransformations getATLTransformations() {
if(atlTransformations == null)
atlTransformations = new ATLTransformations();
return atlTransformations;
}
/**
* Check if input XML file is well-formed - helper method
* @param file path to input XML file or XML code
* @param isFile if it is true then it is path to file, otherwise it
is String that contains XML code
* @return true if input XML file is well formed, otherwise is false
*/
private boolean checkForWellFormedness(String file, boolean isFile)
{
SAXParser saxParser = null;
DefaultHandler dh = null;
InputStream in = null;
// init parser
try {
SAXParserFactory spfactory = SAXParserFactory.newInstance();
saxParser = spfactory.newSAXParser();
dh = new DefaultHandler();
}
catch(Exception e) {
System.out.println("Cannot initialize SAX parser.");
e.printStackTrace();
return false;
}
// parse the XML document using SAX parser
try {
if (isFile == true) { // it is file
in = new FileInputStream(file);
}
else { // it is String that contains XML code
byte currentXMLBytes[] = file.getBytes(); // Get bytes from input
String
in = new ByteArrayInputStream(currentXMLBytes);
}
saxParser.parse(in, dh); // SAXException, IOException
}
catch(SAXParseException spe) { // Document is not well-formed: Error
System.out.println("Document is not well-formed.");
return false;
}
catch(SAXException se) { // (*)
System.out.println("Error while parsing input XML file: " + file);
se.printStackTrace();
return false;
}
catch(FileNotFoundException f) {
System.out.println("Error: File is not found-1");
return false;
}
catch(IOException ioe) {
System.out.println("Cannot read file.");
return false;
}
return true;
} // -- end of checkForWellFormedness
/**
* Inject input XML file to XML model (instance of XML metamodel - MOF
1.4)
* Note: if you want to use EMF, just change 'mdramh' to 'emfamh' and
'xmlMDRmm' to 'xmlEMFmm'
* in this method, and also in other methods if needed.
* @param file name of file from which XML model will be created
* @return created XML model from input file
*/
public ASMModel injectXMLModelFromFile(String file) {
initMDR(); // if MDR is not initialized, do it now !
ASMModel ret = mdramh.newModel("IN", xmlMDRmm); // create new output
model with XML metamodel (MOF-1.4)
XMLInjector xmli = new XMLInjector(); // create XML injector
Map parameters = Collections.EMPTY_MAP; // no parameters
InputStream in = null;
try {
in = new FileInputStream(file);
xmli.inject(ret, in, parameters); // Do injection !
} catch(FileNotFoundException f) {
System.out.println("Error: File is not found-2");
} catch(IOException io) {
System.out.println("Error: in injection of XML file");
}
return ret;
} // -- end of injectXMLModelFromFile
/**
* Convert input String which contains XML code to XML model (instance
of XML metamodel - MOF 1.4)
* @param inputString String which contains XML
* @return created XML model from in XML code
*/
public ASMModel injectXMLModelFromString(String inputString) {
initMDR(); // if MDR is not initialized, do it now !
// Get bytes from input String
byte currentXMLBytes[] = inputString.getBytes();
InputStream in = new ByteArrayInputStream(currentXMLBytes);
ASMModel ret = mdramh.newModel("IN", xmlMDRmm); // create new output
model with XML metamodel (MOF-1.4)
XMLInjector xmli = new XMLInjector(); // create XML injector
Map parameters = Collections.EMPTY_MAP; // no parameters
try {
xmli.inject(ret, in, parameters); // Do injection !
} catch(IOException io){
io.printStackTrace();
}
return ret;
} // -- end of injectXMLModelFromFile
/**
* Extract input XML model (instance of XML metamodel - MOF 1.4) to
XML file
* @param model input XML model which will be extracted to XML file
* @param file output XML file in which input XML model will be
extracted
*/
public void extractXMLModelToFile(ASMModel model, String file) {
initMDR();
OutputStream out = null;
Map parameters = Collections.EMPTY_MAP;
XMLExtractor xmle = new XMLExtractor();
try {
out = new FileOutputStream(file);
xmle.extract(model, out, parameters); // Do extraction !
out.flush(); out.close(); // close stream
} catch(FileNotFoundException f) {
System.out.println("Error: File is not found-3");
} catch(IOException io) {
System.out.println("Error: in extraction of XML model to XML file");
}
} // -- end of extractXMLModelToFile
/**
* Extract input XML model (instance of XML metamodel - MOF 1.4) to
String
* @param model input XML model which will be extracted to XML file
* @return input model returned as String
*/
public String extractXMLModelToString(ASMModel model) {
initMDR();
OutputStream out = null; String ret = null;
Map parameters = Collections.EMPTY_MAP;
XMLExtractor xmle = new XMLExtractor();
try {
out = new ByteArrayOutputStream();
xmle.extract(model, out, parameters); // Do extraction !
ret = out.toString();
out.flush(); out.close(); // close stream
} catch(FileNotFoundException f) {
System.out.println("Error: File is not found-4");
} catch(IOException io) {
System.out.println("Error: in extraction of XML model to XML file");
}
return ret;
} // -- end of extractXMLModelToFile
//////////////////////////////////////////////////////////// /////////////////////////////////////////////////
// An example EBNF inject/extract methods for some MM metamodel (this
should be changed for every metamodel)
// Note: you should have generated MM-ebnfinjector.jar and putted
// in into classpath with other libs
//////////////////////////////////////////////////////////// /////////////////////////////////////////////////
/**
* Extract input MM model (instance of some MM metamodel - MOF 1.4) to
File
* @param MMModel input MM model which will be extracted to File
* @param file path to the file in which will be extracted input MM model
*/
public void saveMMModelToFile(ASMModel MMModel, String file) {
initMDR();
OutputStream out = null;
Extractor ext = new EBNFExtractor();
Map params = new HashMap();
params.put("format", MDRMetaModels.get("MM-TCS"));
params.put("indentString", "\t");
try {
out = new FileOutputStream(file);
ext.extract(MMModel, out, params); // do it!
} catch(Exception e) {
e.printStackTrace();
}
} // -- end of saveMMModelToFile
/**
* Deserializes a MM model from a File. (works with MDR, but if it is
needed, just change to EMF)
* @param file is the MM file.
* @return the MM model that is injected from input MM code.
*/
public ASMModel getMMFromFile(String file) {
initMDR(); // if MDR (and EMF) is not initialized, do it now !
ASMModel ret = mdramh.newModel("IN", oneMM_MDR); // create new output
model with OneMM (or some your MM) metamodel
EBNFInjector2 ebnfi = new EBNFInjector2();
InputStream in = null;
try {
in = new FileInputStream(file);
//Class lexer = MMLexer.class; // This are your generated classes
//Class parser = MMParser.class;
//ebnfi.performImportation(oneMM_MDR, ret, in, "MM", lexer, parser);
in.close();
} catch(FileNotFoundException f) {
System.out.println("Error: File is not found-5");
} catch(IOException io) {
System.out.println("Error: in injection of MM file");
} catch(Exception e) {
e.printStackTrace();
}
// TODO: Check for problems with: int nbPbs =
markerMaker.applyMarkers(file, pbs); ...
return ret;
} // -- end of getMMFromFile
/**
* Launch ATL transformation
* @param modelHandler model handler which is used for creating output
model
* @param transformation URL to compiled ATL transformation
* @param inputModel input model for transformation
* @param inputMetamodel input metamodel for transformation
* @param outputMetamodel output metamodel for transformation
* @param inParams additional parameters for transformation
* @param inLibs additional libraries for transformation
* @throws IOException
*/
public ASMModel runATLTransformation(AtlModelHandler modelHandler, URL
transformation, ASMModel inputModel,
ASMModel inputMetamodel, ASMModel outputMetamodel, Map
inParams, Map inLibs) throws IOException {
initMDR(); // Initialize MDR model handler
ASMModel ret = null; // return model
// Set launch configuration
Map models = new HashMap();
models.put(inputMetamodel.getName(), inputMetamodel); // input metamodel
models.put(outputMetamodel.getName(), outputMetamodel); // output
metamodel
models.put("IN", inputModel); // input model
ret = modelHandler.newModel("OUT", outputMetamodel); // output model
models.put("OUT", ret);
Map params = inParams; // Parameters
Map libs = inLibs; // Libraries
// Launch ATL transformation
AtlLauncher.getDefault().launch(transformation, libs, models, params);
return ret;
} // -- end of runATLTransformation
/**
* Load model from file (XMI) as MOF-1.4
* @param file name of file which containts input model
* @param inputMetamodel input metamodel (as String)
* @return model which is constructed from input file
*/
public ASMModel loadMDRModelFromFile(String file, String inputMetamodel) {
// Initialize MDR
initMDR();
// Get metamodel from map
ASMModel metamodel = (ASMModel)MDRMetaModels.get(inputMetamodel);
InputStream in = null;
try {
// Create input stream from file
in = new FileInputStream(file);
} catch(FileNotFoundException e) {
System.out.println("Error: Input file is not found!");
return null;
}
return mdramh.loadModel(file, metamodel, in);
} // -- end of loadMDRModelFromFile
/**
* Save model to file (XMI) as MOF-1.4
* @param inputModel input model for saving to file
* @param file name of file in which model will be saved
*/
public void saveMDRModelToFile(ASMModel inputModel, String file) {
// Bridge actual problem of saving model outside of Eclipse environment
ASMMDRModel model = (ASMMDRModel)inputModel;
OutputStream out = null;
try {
// Create output stream
out = new FileOutputStream(file);
// Save model
model.save(out);
out.flush(); out.close();
} catch(FileNotFoundException f) {
System.out.println("Error: output file can't be created");
} catch(IOException io) {
System.out.println("Error: model can't be saved to file");
}
} // -- end of saveMDRModelToFile
/**
* Converts MDR ASMModel to String
* @param MOFmodel input model for converting to string
* @return String which containts input model
*/
public String MOFModelToString(ASMModel MOFmodel) {
// Create output stream
ByteArrayOutputStream out = new ByteArrayOutputStream();
String ret = null;
try {
// Save model
((ASMMDRModel)MOFmodel).save(out);
out.flush();
ret = out.toString();
out.close();
} catch(IOException io) {
System.out.println("Error: model to string");
}
return ret;
} // -- end of MOFModelToString
//////////////////////////////////////////////////////////// //////////////////////
//// Specific transformations
//////////////////////////////////////////////////////////// //////////////////////
/**
* Run OneMM to OtherMM (example) ATL transformation (OneMM2OtherMM).
* Note: MDR is used as model handler, if you want to use EMF, just
change 'mdramh' to 'emfamh'
* @param oneModel input ONE model
* @return output (cleaned) OtherMM model
* @throws IOException
*/
public ASMModel getOtherMMFromOneMM(ASMModel oneModel) throws IOException
{
// If you need library, you can add it in following way:
// e.g., Map libs = new HashMap();
// libs.put("XMLHelpers", XMLHelpersurl);
// And you just have to add this 'libs' object instead of the last
Collections.EMPTY_MAP below
// Run transformation and return output model
return runATLTransformation(mdramh, OneMM2OtherMMurl, oneModel,
oneMM_MDR, otherMM_MDR, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
} // -- end of getCleanedXMLFromXML
/**
* Transform input One (XML-based) file to output Other (XML-based) file
- an example with injection/extraction
* @param InputOneFile name of input One XML file
* @param OutputOtherFile name of output Other XML file
* @return Result of running this transformation
* @throws IOException
*/
public String transformOnetoOther(String InputOneFile, String
OutputOtherFile) throws IOException {
// Check is input String well-formed (XML)
if (!checkForWellFormedness(InputOneFile, true)) return new
String("Document is not well-formed.");
ASMModel xmlModel = injectXMLModelFromFile(InputOneFile); // One XML ->
XML model
ASMModel otherModel = getOtherMMFromOneMM(xmlModel); // One XML ->
Other
extractXMLModelToFile(otherModel, OutputOtherFile); // Other -> Other
XML
return new String("OK");
} // -- end of transformOnetoOther
//////////////////////////////////////////////////////////// //////////////////////
//// Main method - used only for testing this class
//////////////////////////////////////////////////////////// //////////////////////
public static void main(String [] arguments) throws IOException {
// Create new instance of this class
ATLTransformations transformation =
ATLTransformations.getATLTransformations();
// Transform input file to output file
String message =
transformation.transformOnetoOther("src/atl/PetriNet.xmi",
"src/atl/PetriNet-private.xmi"); // Message is OK if all goes well
// or document is not well-formed
}
}
|
|
| | |
| Re: [ATL] ATLTransformations [message #79287 is a reply to message #77894] |
Tue, 15 April 2008 18:26  |
| Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hi,
I'm having problems with org.apache.tools.ant.util.FileUtils. The class
FileUtils in this package does not contain the methods
fileNameToURL(String) and fileNameToURI(String) which are used in class
TransfoLauncher. Where can I get the class FileUtils that contains these
methods?
Thanks in advance!
Best regards,
John
|
|
|
| Re: [ATL] ATLTransformations [message #79302 is a reply to message #79287] |
Tue, 15 April 2008 20:59 |
| Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hi,
I've got the JARs and there is no more problems with imports.
The classes AtlCompiler and AtlLauncher (and the Milanovic's ATL template
bundle) must be used for this purpose or only the classes from
org.eclipse.m2m.atl.tests.util?
Thank you in advance!
John
|
|
| | |
| Re: [ATL] ATLTransformations [message #79420 is a reply to message #79346] |
Wed, 16 April 2008 17:20 |
| Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hello,
I need help one more time :}
Is there any class in the package org.eclipse.m2m.atl.tests.util where I
can put the ASM file, models and metamodels path to launch the
transformation?
Best Regards,
John
|
|
|
| Re: [ATL] ATLTransformations [message #79785 is a reply to message #79331] |
Tue, 22 April 2008 16:51 |
| Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hi,
Do the classes that already exists work perfectly to launch ATL
transformations (with MDR as model handler) or are they still in
development?
The classes that were made to the older version of ATL, did they work
properly?
Thanks in advance.
Best Regards,
John
|
|
|
| Re: [ATL] ATLTransformations [message #79800 is a reply to message #79785] |
Tue, 22 April 2008 17:54 |
| Eclipse User |
|
|
|
Originally posted by: bravus.martins.yahoo.com.br
Hello again,
Where should I put the file paths in these classes to launch an ATL
transoformation?
(Sorry, I've been having some difficulties to solve it :( )
Best regards,
John
|
|
|
Goto Forum:
Current Time: Sat Apr 20 14:31:23 GMT 2024
Powered by FUDForum. Page generated in 0.04153 seconds |
] 
Search
Help
Register
Login
Home
