From 92f94b063ec9a65d04178788f3858c750fbf16e7 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Thu, 15 Feb 2018 23:03:20 +0100 Subject: Generation specification -> execution --- .../execution/GenerationTaskExecutor.xtend | 156 +++++++++++++++++++++ .../application/execution/MetamodelLoader.xtend | 17 +-- .../application/execution/ModelLoader.xtend | 40 +++--- .../application/execution/NullWorkspace.xtend | 52 +++++++ .../application/execution/ScopeLoader.xtend | 83 +++++++++++ .../application/execution/ScriptConsole.xtend | 104 ++++++++++++++ .../application/execution/ScriptExecutor.xtend | 111 +++++++++++++++ .../application/execution/SolverLoader.xtend | 28 ++++ .../application/execution/util/VQLParser.xtend | 6 +- 9 files changed, 566 insertions(+), 31 deletions(-) create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/NullWorkspace.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScopeLoader.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptConsole.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src') diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend new file mode 100644 index 00000000..635d9dcc --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend @@ -0,0 +1,156 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask +import hu.bme.mit.inf.dslreasoner.application.validation.MetamodelValidator +import hu.bme.mit.inf.dslreasoner.application.validation.QueryAndMetamodelValidator +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration +import hu.bme.mit.inf.dslreasoner.logic.model.builder.SolutionScope +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.InconsistencyResult +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.UnknownResult +import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic +import hu.bme.mit.inf.dslreasoner.workspace.ProjectWorkspace +import org.eclipse.emf.common.util.URI + +class GenerationTaskExecutor { + val metamodelLoader = new MetamodelLoader + val modelLoader = new ModelLoader + val queryLoader = new QueryLoader + val solverLoader = new SolverLoader + val scopeLoader = new ScopeLoader + + val metamodelValidator = new MetamodelValidator + val queryAndMetamodelValidator = new QueryAndMetamodelValidator + + def executeGenerationTask( + GenerationTask task, + ScriptExecutor scriptExecutor) + { + // 1. Load all resources + + val metamodelSpecification = scriptExecutor.getMetamodelSpecification(task.metamodel) + val patternSpecification = scriptExecutor.getPatternSpecification(task.patterns) + val partialmodelSpecification = scriptExecutor.getPartialModelSpecification(task.partialModel) + val scopeSpecification = scriptExecutor.getScopeSpecification(task.scope) + val configurationMap = scriptExecutor.transformToMap( + scriptExecutor.getConfiguration(task.config)) + val messageFile = scriptExecutor.getFileSpecification(task.targetLogFile) + val debugFolder = scriptExecutor.getFileSpecification(task.debugFolder) + val outputFolder = scriptExecutor.getFileSpecification(task.getTagetFolder) + val statisticsFile = scriptExecutor.getFileSpecification(task.targetStatisticsFile) + + // 2. create console + + val console = new ScriptConsole(true,true, + if(messageFile!==null) URI.createURI(messageFile.path) else null, + if(debugFolder!==null) URI.createURI('''«debugFolder.path»/errors.txt''') else null, + if(statisticsFile!==null) URI.createURI(statisticsFile.path) else null + ) + + // 3. interpret all specification to a description + val metamodelDescriptor = if(metamodelSpecification !== null) { + metamodelLoader.loadMetamodel(metamodelSpecification) + } else { + console.writeError('''Error during the loading of the metamodel: No metamodel specified!''') + throw new IllegalArgumentException('''No metamodel is specified!''') + } + val queryDescriptor = if(patternSpecification !== null) { + this.queryLoader.loadQueries(patternSpecification) + } else { + null + } + val partialModelDescriptor = if(partialmodelSpecification !== null) { + this.modelLoader.loadModel(partialmodelSpecification,scriptExecutor) + } else { + null + } + + // 4. translate all description to a logic problem + val Ecore2Logic ecore2Logic = new Ecore2Logic + val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic) + val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic) + val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic + + var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration()) + var problem = modelGeneration.output + if(partialModelDescriptor !== null) { + problem = instanceModel2Logic.transform( + modelGeneration, + partialModelDescriptor + ).output + } + if(queryDescriptor !== null){ + problem = viatra2Logic.transformQueries( + queryDescriptor.key, + modelGeneration, + new Viatra2LogicConfiguration + ).output + } + + // 5. create a solver and a configuration + // 5.1 initialize + val solver = solverLoader.loadSolver(task.solver,configurationMap) + val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap) + val reasonerWorkspace = if(debugFolder!== null) { + new ProjectWorkspace(debugFolder.path,"") + } else { + new NullWorkspace + } + + // 5.2 set values that defined directly + solverConfig.solutionScope = new SolutionScope => [ + it.numberOfRequiredSolution = if(task.numberSpecified) { + 1 + } else { + task.number + } + ] + solverConfig.typeScopes = scopeLoader.loadScope( + scopeSpecification, + problem, + ecore2Logic, + modelGeneration.trace + ) + + // 6. execute the solver on the problem with the configuration + val runs = if(task.runSpecified) { + task.runs + } else { + 1 + } + console.writeMessage("Start model generation") + + for(run : 1..runs) { + val solution = solver.solve(problem,solverConfig,reasonerWorkspace) + console.writeMessage(solution.soutionDescription.toString) + } + } + + private def dispatch soutionDescription(InconsistencyResult s) { + if(s.representation.size == 1) { + '''Problem is inconsistent!''' + } else { + '''Problem is inconsistent, only «s.representation.size» model can be created!''' + } + } + + private def dispatch soutionDescription(ModelResult s) { + if(s.representation.size == 1) { + '''Problem is consistent!''' + } else { + '''Problem is consistent, «s.representation.size» model generated!''' + } + } + + private def dispatch soutionDescription(UnknownResult s) { + if(s.representation.size == 1) { + '''Unable to solve problem!''' + } else { + '''Unable to solve problem, but «s.representation.size» model generated!''' + } + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend index e554cc69..5e7f84f0 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend @@ -1,29 +1,22 @@ package hu.bme.mit.inf.dslreasoner.application.execution +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor -import java.util.ArrayList -import java.util.LinkedList +import java.util.LinkedHashSet import java.util.List import java.util.Set -import org.eclipse.emf.common.util.URI import org.eclipse.emf.ecore.EAttribute import org.eclipse.emf.ecore.EClass -import org.eclipse.emf.ecore.EDataType import org.eclipse.emf.ecore.EEnum import org.eclipse.emf.ecore.EEnumLiteral -import org.eclipse.emf.ecore.ENamedElement -import org.eclipse.emf.ecore.EPackage import org.eclipse.emf.ecore.EReference import org.eclipse.emf.ecore.EcorePackage import org.eclipse.emf.ecore.resource.Resource -import org.eclipse.emf.ecore.resource.ResourceSet import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement import org.eclipse.xtext.xbase.lib.Functions.Function1 -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry -import java.util.LinkedHashSet class MetamodelLoader { @@ -34,7 +27,7 @@ class MetamodelLoader { public new() { init } - def loadMetamodel(MetamodelSpecification specification, ResourceSet rs) throws IllegalArgumentException { + def loadMetamodel(MetamodelSpecification specification) throws IllegalArgumentException { val Set classes = new LinkedHashSet val Set enums = new LinkedHashSet diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend index 5fc2cdc5..95f14bc1 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend @@ -2,23 +2,31 @@ package hu.bme.mit.inf.dslreasoner.application.execution import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl import org.eclipse.emf.common.util.URI +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelSpecification class ModelLoader { - def loadModel(String path, Context context) { - var URI uri - try { - uri = URI::createURI(path) - } catch(IllegalArgumentException e) { - context.writeError('''Malformed uri: "«uri»"!''') - return null - } - - val resourceSet = new ResourceSetImpl - val resource = resourceSet.getResource(uri,true) - if(resource === null) { - + + def loadModel(PartialModelSpecification specification, ScriptExecutor scriptExecutor) { + val entries = specification.entry + if (entries.size == 1) { + var URI uri + try { + uri = URI::createURI( + scriptExecutor.getFileSpecification(specification.entry.head.path).path + ) + } catch (IllegalArgumentException e) { + return null + } + + val resourceSet = new ResourceSetImpl + val resource = resourceSet.getResource(uri, true) + if (resource === null) { + } else { + return resource.allContents.toList + } } else { - return resource + throw new UnsupportedOperationException('''Currently single partial models are supported''') } - } -} \ No newline at end of file + + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/NullWorkspace.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/NullWorkspace.xtend new file mode 100644 index 00000000..4cc44df3 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/NullWorkspace.xtend @@ -0,0 +1,52 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace +import java.io.ByteArrayOutputStream +import java.io.FileNotFoundException +import java.util.Collections +import java.util.List +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource + +class NullWorkspace extends ReasonerWorkspace{ + + new() { + super(null, null) + } + + static val message = "No workspace is specified!" + + public override ReasonerWorkspace subWorkspace(String targetFolder, String prefix) { + return new NullWorkspace() + } + + override URI getWorkspaceURI() { + throw new UnsupportedOperationException(message) + } + override public void initAndClear() {} + override protected URI getURI(String name) { + throw new UnsupportedOperationException(message) + } + protected override Resource getResource(String name) { + throw new UnsupportedOperationException(message) + } + override public URI writeModel(EObject modelRoot, String name) { } + override public RootType reloadModel(Class type, String name) { + throw new UnsupportedOperationException(message) + } + override public RootType readModel(Class type, String name) { + throw new UnsupportedOperationException(message) + } + override public deactivateModel(String name) { } + override protected void renameFile(String name) { } + + override public List allFiles() { + throw new UnsupportedOperationException(message) + } + override public URI writeText(String name, CharSequence content) { } + + override public String readText(String name) { + throw new UnsupportedOperationException(message) + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScopeLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScopeLoader.xtend new file mode 100644 index 00000000..ee1a92f0 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScopeLoader.xtend @@ -0,0 +1,83 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassTypeScope +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ExactNumber +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntEnumberation +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntegerTypeScope +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntervallNumber +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectTypeScope +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RealEnumeration +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RealTypeScope +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.StringEnumeration +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.StringTypeScope +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem +import org.eclipse.emf.ecore.EClass + +class ScopeLoader { + def TypeScopes loadScope(ScopeSpecification specification, LogicProblem problem, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + val res = new TypeScopes + for(scopeSpecification : specification.scopes) { + setSpecification(scopeSpecification,res,ecore2Logic,trace) + } + return res + } + + def dispatch setSpecification(ObjectTypeScope scope, TypeScopes aggregated, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + //val existingObjects = + aggregated.minNewElements = getLowerLimit(scope.number) + aggregated.maxNewElements = getUpperLimit(scope.number) + } + def dispatch setSpecification(ClassTypeScope scope, TypeScopes aggregated, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + val target = scope.type.element + if(target.feature != null) { + throw new IllegalArgumentException('''Feature scopes are not supported: "«target.feature.name»"!''') + } else { + val targetClassifier = target.classifier + if(targetClassifier instanceof EClass) { + val type = ecore2Logic.TypeofEClass(trace,targetClassifier) + aggregated.minNewElementsByType.put(type,getLowerLimit(scope.number)) + aggregated.maxNewElementsByType.put(type,getUpperLimit(scope.number)) + } else { + throw new IllegalArgumentException('''Non-EClass scopes are not supported: "«targetClassifier.name»"!''') + } + } + } + def dispatch setSpecification(IntegerTypeScope scope, TypeScopes aggregated, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + aggregated.minNewIntegers = scope.number.lowerLimit + aggregated.maxNewIntegers = scope.number.upperLimit + } + def dispatch setSpecification(RealTypeScope scope, TypeScopes aggregated, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + aggregated.minNewReals = scope.number.lowerLimit + aggregated.maxNewReals = scope.number.upperLimit + } + def dispatch setSpecification(StringTypeScope scope, TypeScopes aggregated, Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) { + aggregated.minNewStrings = scope.number.lowerLimit + aggregated.maxNewStrings = scope.number.upperLimit + } + + def dispatch getLowerLimit(IntervallNumber specification) { + return specification.min + } + def dispatch getLowerLimit(ExactNumber specification) { + if(specification.isExactUnlimited) return 0 + else return specification.exactNumber + } + def dispatch getLowerLimit(IntEnumberation specification) { 0 } + def dispatch getLowerLimit(RealEnumeration specification) { 0 } + def dispatch getLowerLimit(StringEnumeration specification) { 0 } + def dispatch getUpperLimit(IntervallNumber specification) { + if(specification.isMaxUnlimited) return -1 + else return specification.maxNumber + } + def dispatch getUpperLimit(ExactNumber specification) { + if(specification.isExactUnlimited) return -1 + else return specification.exactNumber + } + def dispatch getUpperLimit(IntEnumberation specification) { 0 } + def dispatch getUpperLimit(RealEnumeration specification) { 0 } + def dispatch getUpperLimit(StringEnumeration specification) { 0 } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptConsole.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptConsole.xtend new file mode 100644 index 00000000..77c5252a --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptConsole.xtend @@ -0,0 +1,104 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import java.io.File +import java.io.PrintWriter +import java.util.LinkedHashSet +import java.util.LinkedList +import java.util.Map +import org.eclipse.emf.common.util.URI +import java.io.Closeable +import java.io.IOException +import java.util.LinkedHashMap +import java.util.HashMap + +class ScriptConsole implements Closeable { + val boolean printToConsole + val boolean cleanFiles + + val File messageConsoleFile + val File errorConsoleFile + val File statisticsConsoleFile + val Map file2Writer = new HashMap + + val statisticsHeaderBuffer = new LinkedHashSet + val statisticsDataBuffer = new LinkedList> + + static val delimier = ';' + static val empty = "" + + public new( + boolean printToConsole, + boolean cleanFiles, + URI messageConsoleURI, + URI errorConsoleURI, + URI statisticsConsoleURI) + { + this.printToConsole = printToConsole + this.cleanFiles = cleanFiles + this.messageConsoleFile = messageConsoleURI.prepareFile + this.errorConsoleFile = errorConsoleURI.prepareFile + this.statisticsConsoleFile = statisticsConsoleURI.prepareFile + } + + public def writeMessage(String message) { + messageConsoleFile.writeToFile(message) + } + public def writeError(String message) { + errorConsoleFile.writeToFile(message) + } + public def writeStatistics(LinkedHashMap statistics) { + val message = ''' + «FOR key : statistics.keySet SEPARATOR delimier»«key»«ENDFOR» + «FOR value : statistics.values SEPARATOR delimier»«value»«ENDFOR»''' + statisticsConsoleFile.writeToFile(message) + } + public def addStatistics(LinkedHashMap statistics) { + for(key : statistics.keySet) { + this.statisticsHeaderBuffer.add(key); + } + this.statisticsDataBuffer.add(statistics) + } + public def flushStatistics() { + val message = ''' + «FOR key : statisticsHeaderBuffer SEPARATOR delimier»«key»«ENDFOR» + «FOR line : statisticsDataBuffer » + «FOR key : statisticsHeaderBuffer»«IF line.containsKey(key)»«empty»«ELSE»«line.get(key)»«ENDIF»«ENDFOR» + «ENDFOR» + ''' + statisticsConsoleFile.writeToFile(message) + } + /** + * Writes a line of text to a file and the console. Initializes a writer to the file for at the first message. + */ + private def writeToFile(File file, String text) { + if(file != null) { + val writer = if(this.file2Writer.containsKey(file)) { + this.file2Writer.get(file) + } else { + if(!file.exists) { + file.createNewFile + } + val writer = new PrintWriter(file, "UTF-8"); + this.file2Writer.put(file,writer) + writer + } + writer.println(text) + } + if(printToConsole) { + println(text) + } + } + + private def prepareFile(URI uri) { + val fileString = uri.toFileString + val file = new File(fileString) + if(this.cleanFiles && file.exists) { + file.delete + } + return file + } + + override close() throws IOException { + this.file2Writer.values.forEach[close] + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend new file mode 100644 index 00000000..32d44540 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend @@ -0,0 +1,111 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GraphPatternReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.Task +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FileSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FileReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigReference +import java.util.LinkedHashMap + +class ScriptExecutor { + + def static void main(String[] args) { + println("generator") + } + + public def executeScript(ConfigurationScript script) { + val tasks = script.commands.filter(Task) + for(task : tasks.filterNull) { + task.execute + } + } + + def public dispatch execute(GenerationTask task) { + + } + + def public dispatch execute(Task task) { + throw new IllegalArgumentException('''Unsupported task type: «task.class.simpleName»!''') + } + + def dispatch getMetamodelSpecification(MetamodelSpecification config) { + config + } + def dispatch getMetamodelSpecification(MetamodelReference config) { + config.referred.specification + } + def dispatch getMetamodelSpecification(Void config) { + null + } + + def dispatch getPatternSpecification(PatternSpecification config) { + config + } + def dispatch getPatternSpecification(GraphPatternReference config) { + config.referred.specification + } + def dispatch getPatternSpecification(Void config) { + null + } + + def dispatch getPartialModelSpecification(PartialModelSpecification config) { + config + } + def dispatch getPartialModelSpecification(PartialModelReference config) { + config.referred.specification + } + def dispatch getPartialModelSpecification(Void config) { + null + } + + def dispatch getFileSpecification(FileSpecification config) { + config + } + def dispatch getFileSpecification(FileReference config) { + config.referred.specification + } + def dispatch getFileSpecification(Void config) { + null + } + + def dispatch getScopeSpecification(ScopeSpecification config) { + config + } + def dispatch getScopeSpecification(ScopeReference config) { + config.referred.specification + } + def dispatch getScopeSpecification(Void config) { + null + } + + def dispatch getConfiguration(ConfigSpecification config) { + config + } + def dispatch getConfiguration(ConfigReference config) { + config.config.specification + } + def dispatch getConfiguration(Void config) { + null + } + def transformToMap(ConfigSpecification config) { + val map = new LinkedHashMap + + if(config != null) { + for(entry : config.entries) { + map.put(entry.key,entry.value) + } + } + + return map + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend new file mode 100644 index 00000000..dcd89981 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend @@ -0,0 +1,28 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.Solver +import java.util.Map +import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolver +import hu.bme.mit.inf.dslreasoner.smt.reasoner.SMTSolver +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner +import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolverConfiguration +import hu.bme.mit.inf.dslreasoner.smt.reasoner.SmtSolverConfiguration +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration + +class SolverLoader { + def loadSolver(Solver solver, Map config) { + switch(solver) { + case ALLOY_SOLVER: return new AlloySolver + case SMT_SOLVER: return new SMTSolver + case VIATRA_SOLVER: return new ViatraReasoner + } + } + + def loadSolverConfig(Solver solver, Map config) { + switch(solver) { + case ALLOY_SOLVER: return new AlloySolverConfiguration + case SMT_SOLVER: return new SmtSolverConfiguration + case VIATRA_SOLVER: return new ViatraReasonerConfiguration + } + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend index 6eb9e3c8..e6d516f4 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend @@ -3,7 +3,6 @@ package hu.bme.mit.inf.dslreasoner.application.execution.util import com.google.inject.Guice import com.google.inject.Injector import com.google.inject.Module -import hu.bme.mit.inf.dslreasoner.application.execution.Context import java.util.LinkedHashMap import java.util.List import org.eclipse.emf.common.util.URI @@ -21,6 +20,7 @@ import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternMo import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder import org.eclipse.viatra.query.runtime.api.IQuerySpecification import org.eclipse.xtext.resource.XtextResourceSet +import hu.bme.mit.inf.dslreasoner.application.execution.ScriptConsole class MyModule extends EMFPatternLanguageRuntimeModule implements Module { def public Class bindAnnotationValidatorLoader() { @@ -58,7 +58,7 @@ class VQLParser { * the linked patterns are loaded validated and translated to a {@link IQuerySpecification} object. * @returns uri -> (name -> pattern) */ - public def parse(List uris, ResourceSet resourceSet, Context context) { + public def parse(List uris, ResourceSet resourceSet, ScriptConsole context) { val res = new LinkedHashMap val uri2resource = new LinkedHashMap @@ -91,7 +91,7 @@ class VQLParser { return res } - def private validate(Resource resource, String URI, Context context) { + def private validate(Resource resource, String URI, ScriptConsole context) { val errors = resource.errors errors.forEach[context.writeError('''Error in loading pattern "«URI»": «it»''')] } -- cgit v1.2.3-54-g00ecf