package br.edu.ufcg.mdaveritas.mofscriptExecutor;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.xmi.XMIResource;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
import org.eclipse.mofscript.parser.MofScriptParseError;
import org.eclipse.mofscript.parser.ParserUtil;
import org.eclipse.mofscript.runtime.ExecutionManager;
import org.eclipse.mofscript.runtime.ExecutionMessageListener;
import org.eclipse.mofscript.runtime.MofScriptExecutionException;
/**
* @author Antonio Dias dos Santos Junior
*
*/
public class MOFScriptExecutor implements ExecutionMessageListener {
private String compilepath;
private String metamodel;
private String metamodelname;
private String model;
private String transformation;
private String outputdir;
private String getMetamodelname() {
return metamodelname;
}
private void setMetamodelname(String metamodelname) {
this.metamodelname = metamodelname;
}
private String getCompilepath() {
return compilepath;
}
private void setCompilepath(String compilepath) {
this.compilepath = compilepath;
}
private String getMetamodel() {
return metamodel;
}
private void setMetamodel(String metamodel) {
this.metamodel = metamodel;
}
private String getModel() {
return model;
}
private void setModel(String model) {
this.model = model;
}
private String getTransformation() {
return transformation;
}
private void setTransformation(String transformation) {
this.transformation = transformation;
}
private String getOutputdir() {
return outputdir;
}
private void setOutputdir(String outputdir) {
this.outputdir = outputdir;
}
/**
* Sets the parameters necessary to the transformation.
*
* @param compilepath
* the compile path
* @param metamodel
* the path to the metamodel file
* @param metamodelname
* the name used to identify the metamodel in the MOFScript
* transformation
* @param model
* the path to the model file
* @param transformation
* the path to the transformation file
* @param outputdir
* the output directory, where the code will be generated
*/
public void setParameters(String compilepath, String metamodel,
String metamodelname, String model, String transformation,
String outputdir) {
setCompilepath(compilepath);
setMetamodel(metamodel);
setMetamodelname(metamodelname);
setModel(model);
setTransformation(transformation);
setOutputdir(outputdir);
}
private void makeTransformation() throws MofScriptExecutionException,
IOException {
ParserUtil parserUtil = new ParserUtil();
ExecutionManager execMgr = ExecutionManager.getExecutionManager();
execMgr.lookupAndAddSourceMetaModel("uml","http://www.eclipse.org/uml2/2.1.0/UML");
parserUtil.setCompilePath(getCompilepath());
parserUtil.parse(new File(getTransformation()), true);
// check for errors:
int errorCount = ParserUtil.getModelChecker().getErrorCount();
Iterator<?> errorIt = ParserUtil.getModelChecker().getErrors();
writeErroLog(errorCount, errorIt);
execMgr.setRootDirectory(getOutputdir());
registryFactoryToJAS();
executeTransformation(execMgr, getModel());
}
private EObject loadSourceModel(String path) {
XMIResourceFactoryImpl _xmiFac = new XMIResourceFactoryImpl();
EObject sourceModel = null;
File sourceModelFile = new File(path);
ResourceSet rSet = new ResourceSetImpl();
rSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put("*",
_xmiFac);
URI uri = URI.createFileURI(sourceModelFile.getAbsolutePath());
Resource resource = rSet.getResource(uri, true);
if (resource != null) {
if (resource.getContents().size() > 0) {
sourceModel = (EObject) resource.getContents().get(0);
}
}
return sourceModel;
}
private void executeTransformation(ExecutionManager execMgr, String fileLoad)
throws MofScriptExecutionException {
// load source model
EObject sourceModel = loadSourceModel(fileLoad);
// set the source model for the execution manager
execMgr.addSourceModel(sourceModel);
// if true, files are not generated to the file system, but populated
// into a filemodel which can be fetched afterwards.
// Value false will result in standard file generation
execMgr.setUseFileModel(false);
// Turns on/off system logging
execMgr.setUseLog(false);
// Adds an output listener for the transformation execution.
execMgr.getExecutionStack().addOutputMessageListener(this);
execMgr.executeTransformation();
execMgr.clearModelTypeMap();
}
private void registryFactoryToJAS() {
Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(
"txt", new XMIResourceFactoryImpl() {
public Resource createResource(URI uri) {
XMIResource xmiResource = new XMIResourceImpl(uri);
return xmiResource;
}
});
}
private void writeErroLog(int errorCount, Iterator<?> errorIt) {
System.out.println("Parsing result: " + errorCount + " errors");
if (errorCount > 0) {
for (; errorIt.hasNext();) {
MofScriptParseError parseError = (MofScriptParseError) errorIt
.next();
System.out.println("\t \t: Error: " + parseError.toString());
}
return;
}
}
public void executionMessage(String type, String description) {
System.out.println(type + " - " + description);
}
/**
* Executes the transformation.
*/
public void executeTransformations() {
try {
makeTransformation();
} catch (MofScriptExecutionException e) {
new RuntimeException(e);
} catch (IOException e) {
new RuntimeException(e);
}
}
public static void main(String[] args) {
MOFScriptExecutor mof = new MOFScriptExecutor();
mof
.setParameters(
"D:\\workspace\\MOFScriptExec",
"",
"uml", "D:\\workspace\\UML2Alloy\\My.uml",
"D:\\workspace\\UML2Alloy\\UML2Alloy.m2t",
"D:\\workspace\\MOFScriptExec");
mof.executeTransformations();
}
}