From 7e50434905cbb7f5d03636033b698e17a9075e9d Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 13 Jan 2018 19:33:26 +0100 Subject: Initial commit of the configuration language and application --- .../application/ApplicationConfiguration.xtext | 127 +++++++++++++++ .../ApplicationConfigurationRuntimeModule.xtend | 43 +++++ .../ApplicationConfigurationStandaloneSetup.xtend | 15 ++ .../GenerateApplicationConfiguration.mwe2 | 43 +++++ .../application/execution/Context.xtend | 18 +++ .../application/execution/ExecuteScript.xtend | 25 +++ .../application/execution/Executor.xtend | 95 +++++++++++ .../application/execution/MetamodelLoader.xtend | 178 +++++++++++++++++++++ .../application/execution/ModelLoader.xtend | 11 ++ .../application/execution/QueryLoader.xtend | 28 ++++ .../application/execution/util/VQLParser.xtend | 99 ++++++++++++ .../ApplicationConfigurationGenerator.xtend | 25 +++ .../ApplicationConfigurationLinkingService.xtend | 56 +++++++ .../ApplicationConfigurationScopeProvider.xtend | 94 +++++++++++ .../ApplicationConfigurationValidator.xtend | 25 +++ 15 files changed, 882 insertions(+) create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationRuntimeModule.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationStandaloneSetup.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ExecuteScript.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Executor.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/generator/ApplicationConfigurationGenerator.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/validation/ApplicationConfigurationValidator.xtend (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf') diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext new file mode 100644 index 00000000..ed83419f --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext @@ -0,0 +1,127 @@ +grammar hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration with org.eclipse.xtext.common.Terminals + +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.eclipse.org/viatra/query/patternlanguage/PatternLanguage" as viatra +generate applicationConfiguration "http://www.bme.hu/mit/inf/dslreasoner/application/ApplicationConfiguration" + +ConfigurationScript: + (imports += Import)* + (commands += Command)* +; + +Command : + Declaration + //| Task +; +Declaration : +// FileDeclaration | + MetamodelDeclaration +// | PartialModelDeclaration +// | GraphPatternDeclaration +// | SolverConfig +; + +/////////////////////////////////////////////////// +// Imports +/////////////////////////////////////////////////// + +Import: EPackageImport | ViatraImport; + +EPackageImport: "import" "epackage" importedPackage=[ecore::EPackage|STRING]; +ViatraImport: "import" "viatra" importedViatra=[viatra::PatternModel|STRING]; + +/////////////////////////////////////////////////// +// Files and Folders +/////////////////////////////////////////////////// +/* +FileSpecification: path = STRING; +FileDeclaration: 'file' name = ID '=' specification = FileSpecification; + +FileReference: referred = [FileDeclaration]; +File: FileSpecification | FileReference; +*/ +/////////////////////////////////////////////////// +// Metamodel +/////////////////////////////////////////////////// + +MetamodelSpecification: '{' (entries += MetamodelEntry) (',' entries += MetamodelEntry)* '}'; +MetamodelEntry: MetamodelElement | AllPackageEntry; +AllPackageEntry: "package" package=[ecore::EPackage] ("excluding" '{'exclusion +=MetamodelElement (',' exclusion +=MetamodelElement)*'}')?; +MetamodelElement: (package=[ecore::EPackage] '::')? classifier = [ecore::EClassifier] ('.' feature= [ecore::ENamedElement])?; + +MetamodelDeclaration: 'metamodel' name = ID specification = MetamodelSpecification; +MetamodelReference: referred = [MetamodelDeclaration]; +Metamodel: MetamodelReference | MetamodelSpecification; + +/////////////////////////////////////////////////// +// Partial Model +/////////////////////////////////////////////////// +/* +PartialModelEntry: path = File; +PartialModelSpecification: entry += PartialModelEntry ('+' entry += PartialModelEntry)*; +PartialModelDeclaration: 'partial-model' name = ID '=' specification = PartialModelSpecification; +PartialModelReference : referred = [PartialModelDeclaration]; +PartialModel: PartialModelSpecification | PartialModelReference; +*/ +/////////////////////////////////////////////////// +// Patterns +/////////////////////////////////////////////////// +/* +PatternSpecification: '{' entries += PatternEntry (',' entries += PatternEntry)* '}'; +PatternEntry: PatternElement | AllPatternEntry; +AllPatternEntry: package = [viatra::PatternModel] ('excluding' '{' exclusuion += PatternElement (',' exclusuion += PatternElement)* '}')?; +PatternElement: pattern = [viatra::Pattern]; + +GraphPatternDeclaration: 'patterns' name = ID specification = PatternSpecification; +GraphPatternReference: referred = [GraphPatternDeclaration]; +GraphPattern: GraphPatternReference|PatternSpecification; +*/ +/////////////////////////////////////////////////// +// SolverConfig +/////////////////////////////////////////////////// +/* +SolverConfig : SMTSolverConfig | AlloySolverConfig | ViatraSolverConfig; + +SMTSolverConfig: + 'smt-solver-config' name = ID '{' + 'solver-path' '=' solverPath = File + '}' +; + +AlloySolverConfig: + 'alloy-solver-config' name = ID '{' + ('symmetry' '=' symmetry=INT)? + '}' +; + +ViatraSolverConfig: + 'viatra-solver-config' name = ID '{' + ('statecoding' '=' statecoding = ViatraStatecoder)? & + ('type-inferencing' '=' typeinferencing = ViatraTypeInferencing)? & + ('backtrack-chance' '=' backtrackChance = INT)? + '}' +; +enum ViatraStatecoder: neighbourhood | identifier; +enum ViatraTypeInferencing: preliminary | online; + +Solver: SMTSolver | AlloySolver | ViatraSolver; + +SMTSolver: 'smt-solver' '(' (config = [SMTSolverConfig]) ')'; +AlloySolver: 'alloy-solver' {AlloySolver} '(' (config = [AlloySolverConfig]|'default') ')'; +ViatraSolver: 'viatra-solver' {ViatraSolver} '(' (config= [ViatraSolverConfig]|'default')')'; + +Task: GenerationTask; + +GenerationTask: 'generate' '{' + ('metamodel' '=' metamodel = Metamodel) & + ('partial-model' '=' partialModel = PartialModel)? & + ('patterns' '=' patterns = GraphPattern)? & + ('new-objects' '=' size = INT) & + ('number' '=' number= INT)? & + ('runs' '=' runs = INT)? + 'target-folder' '=' tagetFolder = File + 'debug-folder' '=' debugFolder = File + ('log' '=' targetLogFile = File)? + ('statistics' '=' targetStatisticsFile = File)? + '}' +;*/ \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationRuntimeModule.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationRuntimeModule.xtend new file mode 100644 index 00000000..919dd297 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationRuntimeModule.xtend @@ -0,0 +1,43 @@ +/* + * generated by Xtext 2.10.0 + */ +package hu.bme.mit.inf.dslreasoner.application + +import hu.bme.mit.inf.dslreasoner.application.linking.ApplicationConfigurationLinkingService +import com.google.inject.Binder +import com.google.inject.multibindings.Multibinder +import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProviderInstance +import org.apache.log4j.Logger +import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProvider +import org.eclipse.viatra.query.patternlanguage.emf.scoping.CompoundMetamodelProviderService +import org.eclipse.viatra.query.patternlanguage.emf.scoping.MetamodelProviderService +import org.eclipse.viatra.query.patternlanguage.emf.scoping.ResourceSetMetamodelProviderService +import org.eclipse.viatra.query.patternlanguage.emf.IGenmodelMappingLoader +import org.eclipse.viatra.query.patternlanguage.emf.GenmodelExtensionLoader + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +class ApplicationConfigurationRuntimeModule extends AbstractApplicationConfigurationRuntimeModule { + override bindILinkingService() { + ApplicationConfigurationLinkingService + } + + def configureLoggerImplementation(Binder binder) { + binder.bind(Logger).toInstance(Logger.getLogger(ApplicationConfigurationRuntimeModule)) + } + + def Class bindIMetamodelProvider() { + CompoundMetamodelProviderService + } + + def configureMetamodelProviderInstance(Binder binder) { + val metamodelProviderBinder = Multibinder.newSetBinder(binder, IMetamodelProviderInstance) + metamodelProviderBinder.addBinding.to(MetamodelProviderService) + metamodelProviderBinder.addBinding.to(ResourceSetMetamodelProviderService) + } + + def Class bindIGenmodelMappingLoader() { + GenmodelExtensionLoader + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationStandaloneSetup.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationStandaloneSetup.xtend new file mode 100644 index 00000000..ef07c9b3 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfigurationStandaloneSetup.xtend @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.10.0 + */ +package hu.bme.mit.inf.dslreasoner.application + + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +class ApplicationConfigurationStandaloneSetup extends ApplicationConfigurationStandaloneSetupGenerated { + + def static void doSetup() { + new ApplicationConfigurationStandaloneSetup().createInjectorAndDoEMFRegistration() + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 new file mode 100644 index 00000000..9265ce4a --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 @@ -0,0 +1,43 @@ +module hu.bme.mit.inf.dslreasoner.application.GenerateApplicationConfiguration + +import org.eclipse.xtext.xtext.generator.* +import org.eclipse.xtext.xtext.generator.model.project.* + +var rootPath = ".." + +Workflow { + + component = XtextGenerator { + + configuration = { + project = StandardProjectConfig { + + baseName = "hu.bme.mit.inf.dslreasoner.application" + rootPath = rootPath + + eclipsePlugin = { + enabled = true + } + createEclipseMetaData = true + + } + code = { + encoding = "UTF-8" + fileHeader = "/*\n * generated by Xtext \${version}\n */" + + } + } + language = StandardLanguage { + name = "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration" + referencedResource = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" + referencedResource = "platform:/resource/org.eclipse.viatra.query.patternlanguage/model/generated/PatternLanguage.genmodel" + fileExtensions = "vsconfig" + serializer = { + generateStub = false + } + validator = { + // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" + } + } + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend new file mode 100644 index 00000000..8f72caed --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend @@ -0,0 +1,18 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import java.io.OutputStream +import java.util.LinkedList +import java.util.List +import java.io.FileWriter +import org.eclipse.xtend.lib.annotations.Accessors + +class Context { + @Accessors(PUBLIC_GETTER,PUBLIC_SETTER) + var boolean printToConsole = true + + def writeError(Object object) { + if(printToConsole) { + println(object) + } + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ExecuteScript.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ExecuteScript.xtend new file mode 100644 index 00000000..403d00d8 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ExecuteScript.xtend @@ -0,0 +1,25 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import org.apache.log4j.Logger +import org.apache.log4j.LogManager +import org.apache.log4j.Level +import java.io.PrintStream +import java.io.OutputStream +import java.io.BufferedWriter +import java.io.Writer + +class ExecuteScript { + def static void main(String[] args) { + val Logger logger = LogManager.getLogger(ExecuteScript); + logger.level = Level::DEBUG + + println() + System.out.println("asd") + + logger.debug("debug") + logger.info("info") + logger.warn("warning") + logger.error("error") + logger.fatal("fatal") + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Executor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Executor.xtend new file mode 100644 index 00000000..4d887423 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Executor.xtend @@ -0,0 +1,95 @@ +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.Task +import java.util.HashMap +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.Metamodel +import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace +import java.util.List +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EEnumLiteral +import org.eclipse.emf.ecore.EReference +import org.eclipse.emf.ecore.EEnum +import org.eclipse.emf.ecore.EAttribute +import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace +import org.eclipse.emf.ecore.EObject +import java.util.LinkedHashMap +import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml +import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolverConfiguration +import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolver +import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner +import java.util.LinkedList +import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisation +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicStructureBuilder +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.EPackage + +class Executor { + public def void execute(ConfigurationScript configurationScript) { + val tasks = configurationScript.commands.filter(Task) + val numberOfModels = tasks.map[it.calculateTaskSteps].reduce[p1, p2|p1+p2] + } + + def private dispatch calculateTaskSteps(Task task) { + throw new UnsupportedOperationException() + } + def private dispatch calculateTaskSteps(GenerationTask task) { + return task.number * task.runs + } + + def private dispatch executeTask(Task task) { + throw new UnsupportedOperationException() + } + def private dispatch executeTask(GenerationTask generationTask) { + val metamodel = generationTask.metamodel + if(metamodel != null) { + + } + } + + def protected loadPackage(ResourceSet rs, String path) { + var EObject content = null + + try { + val resource = rs.getResource(URI.createURI(path),true) + content = resource.contents.get(0) + } catch(IllegalArgumentException e) { + return null + } catch(RuntimeException e) { + return null + } + + if(content instanceof EPackage) { + + } else return null + } + + def loadPatternModel(ResourceSet rs, String path) { + var model = null + + + } +} 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 new file mode 100644 index 00000000..126dbb7d --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend @@ -0,0 +1,178 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassElement +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FeatureElement +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.HashMap +import java.util.LinkedList +import java.util.List +import java.util.Map +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 org.eclipse.xtend.lib.annotations.Data + +@Data +class Metamodel { + List packages + EcoreMetamodelDescriptor descriptor +} + +class MetamodelLoader { + + def private static init() { + EcorePackage.eINSTANCE.EClass + Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("ecore",new XMIResourceFactoryImpl) + } + + public new() { init } + + def loadMetamodel(List specification, ResourceSet rs, Context context) { + + } + + def loadMetamodel(MetamodelSpecification specification, ResourceSet rs, Context context) { + val Map> entry2Packages = new HashMap + + for(entry : specification.entries) { + val packagesInEntry = entry.path.path.loadPackageFromPath(rs,context) + entry2Packages.put(entry,packagesInEntry) + } + + return entry2Packages + } + + public def pruneMetamodel(Map> specification, ResourceSet rs, Context context) { + val List classes = new LinkedList + val List enums = new LinkedList + val List literals = new LinkedList + val List references = new LinkedList + val List attributes = new LinkedList + + + /** Add all included types */ + for(entry : specification.entrySet) { + val metamodelEntry = entry.key + val packages = entry.value + + /** Excluted types */ + val excludedTypeNames = metamodelEntry.excluding.filter(ClassElement).map[name].toSet + /** Excluded features */ + val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet + + /** Load the types */ + for(package : packages) { + for(class : package.EClassifiers.filter(EClass)) { + classes.addIfNotExcluded(class,excludedTypeNames) + } + for(enum : package.EClassifiers.filter(EEnum)) { + val added = enums.addIfNotExcluded(enum,excludedTypeNames) + if(added) { + for(literal : enum.ELiterals) { + literals.addIfNotExcluded(literal,enum,excludedFeatureNames) + } + } + } + } + } + + /** Add all included references and attributes*/ + for(entry : specification.entrySet) { + val metamodelEntry = entry.key + val packages = entry.value + + /** Excluded features */ + val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet + + /** See if type is included */ + for(package : packages) { + for(class : package.EClassifiers.filter(EClass)) { + if(classes.contains(class)) { + for(reference : class.EReferences) { + if(classes.contains(reference.EType)) { + references.addIfNotExcluded(reference,class,excludedFeatureNames) + } + } + for(attribute : class.EAttributes) { + val type = attribute.EType + if(type instanceof EEnum) { + if(enums.contains(type)) { + attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) + } else if(type == EcorePackage.Literals) { + if(enums.contains(type)) { + attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) + } + } + } else if(supportedEDataType(type as EDataType)) { + attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) + } + } + } + } + } + } + } + + private def supportedEDataType(EDataType dataType) { + val extension l = EcorePackage.eINSTANCE + return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType) + } + + private def addIfNotExcluded( + List target, + T element, + Set excluded) + { + if(excluded.contains(element.name)) { + target += element + return true + } else { + return false + } + } + private def addIfNotExcluded( + List target, + T1 element, + ENamedElement container, + Set> excluded) + { + val pair = (container.name) -> (element.name) + + if(excluded.contains(pair)) { + target += element + } + } + + private def List loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException { + var Resource resource; + try{ + resource = rs.getResource(URI.createURI(path),true) + } catch(RuntimeException e) { + context.writeError('''Unable to load EPackage: Error in path "«path»"!''') + return #[] + } + val res = new ArrayList(resource.contents.size) + for(content: resource.contents) { + if(content instanceof EPackage) { + res += content + } else { + context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''') + } + } + return res + } +} \ No newline at end of file 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 new file mode 100644 index 00000000..1de7ee22 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ModelLoader.xtend @@ -0,0 +1,11 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +class ModelLoader { + //def loadMetamodels()7 +// val List classes = new LinkedList +// val List references = new LinkedList +// val List attributes = new LinkedList +// val List enums = new LinkedList +// val List literals = new LinkedList +// +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend new file mode 100644 index 00000000..8c064cd3 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend @@ -0,0 +1,28 @@ +package hu.bme.mit.inf.dslreasoner.application.execution + +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification +import hu.bme.mit.inf.dslreasoner.application.execution.util.VQLParser +import java.util.LinkedHashMap +import org.eclipse.emf.ecore.resource.ResourceSet + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* + +class QueryLoader { + val parser = new VQLParser + + def loadQueries(PatternSpecification specification, ResourceSet rs, Context context) { + val uris = specification.entries.map[path].toList + val models = parser.parse(uris,rs,context) + + val res = new LinkedHashMap + for(entry : specification.entries) { + res.put(entry,entry.path.lookup(models)) + } + + return res + } + + def pruneQueries(PatternSpecification specification, ResourceSet rs, Context context) { + + } +} \ 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 new file mode 100644 index 00000000..9b5c538f --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/util/VQLParser.xtend @@ -0,0 +1,99 @@ +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 java.util.LinkedHashMap +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.viatra.query.patternlanguage.PatternLanguageStandaloneSetup +import org.eclipse.viatra.query.patternlanguage.annotations.ExtensionBasedAnnotationValidatorLoader +import org.eclipse.viatra.query.patternlanguage.annotations.IAnnotationValidatorLoader +import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageRuntimeModule +import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup +import org.eclipse.viatra.query.patternlanguage.emf.GenmodelExtensionLoader +import org.eclipse.viatra.query.patternlanguage.emf.IGenmodelMappingLoader +import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel +import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder +import org.eclipse.xtext.resource.XtextResourceSet +import hu.bme.mit.inf.dslreasoner.application.execution.Context +import java.util.List +import java.util.HashMap +import org.eclipse.viatra.query.runtime.api.IQuerySpecification + +class MyModule extends EMFPatternLanguageRuntimeModule implements Module { + def public Class bindAnnotationValidatorLoader() { + return typeof(ExtensionBasedAnnotationValidatorLoader); + } + def public Class bindGenmodelMappingLoader() { + return typeof(GenmodelExtensionLoader); + } +} + +class VQLParser { + val Injector injector; + val SpecificationBuilder builder = new SpecificationBuilder + + new() { + PatternLanguageStandaloneSetup.doSetup + EMFPatternLanguageStandaloneSetup.doSetup; + + injector = internalCreateInjector + } + + def protected Injector internalCreateInjector() { + new EMFPatternLanguageStandaloneSetup().createInjectorAndDoEMFRegistration(); + val Module module = new MyModule + val newInjector = Guice.createInjector(module) + return newInjector; + } + + public def createResourceSet() { + injector.getInstance(XtextResourceSet); + } + + /** + * Load patterns in two steps: first, the pattern models are are loaded to a resource set, then + * 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) { + val res = new LinkedHashMap + val uri2resource = new LinkedHashMap + + for(uri : uris) { + var Resource resource + var PatternModel patternModel + try { + resource = resourceSet.getResource(URI.createURI(uri),true); + patternModel = resource.getContents().get(0) as PatternModel; + uri2resource.put(uri,patternModel) + } catch(RuntimeException e) { + context.writeError('''Unable to load patterns from "«uri»"!''') + } + } + + for(entry : uri2resource.entrySet) { + val uri = entry.key + val model = entry.value + EcoreUtil.resolveAll(model.eResource) + model.eResource.validate(uri, context) + + val map = new LinkedHashMap + for(pattern : model.patterns) { + val IQuerySpecification querySpecification = (this.builder as SpecificationBuilder).getOrCreateSpecification(pattern) + map.put(querySpecification.fullyQualifiedName.split('.').last,querySpecification) + } + res.put(uri,map) + } + + return res + } + + def private validate(Resource resource, String URI, Context context) { + val errors = resource.errors + errors.forEach[context.writeError('''Error in loading pattern "«URI»": «it»''')] + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/generator/ApplicationConfigurationGenerator.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/generator/ApplicationConfigurationGenerator.xtend new file mode 100644 index 00000000..22b46367 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/generator/ApplicationConfigurationGenerator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.10.0 + */ +package hu.bme.mit.inf.dslreasoner.application.generator + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +class ApplicationConfigurationGenerator extends AbstractGenerator { + + override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { +// fsa.generateFile('greetings.txt', 'People to greet: ' + +// resource.allContents +// .filter(typeof(Greeting)) +// .map[name] +// .join(', ')) + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend new file mode 100644 index 00000000..15567f88 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend @@ -0,0 +1,56 @@ +package hu.bme.mit.inf.dslreasoner.application.linking + +import com.google.inject.Inject +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport +import java.util.Collections +import java.util.Optional +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProvider +import org.eclipse.xtext.conversion.IValueConverterService +import org.eclipse.xtext.conversion.ValueConverterException +import org.eclipse.xtext.linking.impl.DefaultLinkingService +import org.eclipse.xtext.nodemodel.ILeafNode +import org.eclipse.xtext.nodemodel.INode + +class ApplicationConfigurationLinkingService extends DefaultLinkingService{ + + //@Inject Logger logger + + @Inject IValueConverterService valueConverterService + + @Inject IMetamodelProvider metamodelProvider + + public static extension ApplicationConfigurationPackage pac = ApplicationConfigurationPackage.eINSTANCE + + override getLinkedObjects(EObject context, EReference ref, INode node) { + if(context instanceof EPackageImport) { + if(ref == EPackageImport_ImportedPackage && node instanceof ILeafNode) { + return getEPackage(context as EPackageImport, node as ILeafNode) + } + } else if(context instanceof ViatraImport) { + super.getLinkedObjects(context, ref, node) + } + return super.getLinkedObjects(context, ref, node) + } + + private def getEPackage(EPackageImport packageImport, ILeafNode node) { + getMetamodelNsUri(node).flatMap [ uri | + Optional.ofNullable(metamodelProvider.loadEPackage(uri, packageImport.eResource.resourceSet)) + ].map [ ePackage | + Collections.singletonList(ePackage as EObject) + ].orElse(emptyList) + } + + private def getMetamodelNsUri(ILeafNode node) { + try { + val convertedValue = valueConverterService.toValue(node.text, + linkingHelper.getRuleNameFrom(node.grammarElement), node) + Optional.of(convertedValue as String) + } catch (ValueConverterException e) { + Optional.empty + } + } +} \ No newline at end of file diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend new file mode 100644 index 00000000..4eef53d7 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend @@ -0,0 +1,94 @@ +/* + * generated by Xtext 2.10.0 + */ +package hu.bme.mit.inf.dslreasoner.application.scoping + +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage +import org.eclipse.xtext.EcoreUtil2 +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport +import org.eclipse.xtext.scoping.Scopes +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EEnum +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry + +/** + * This class contains custom scoping description. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping + * on how and when to use it. + */ +class ApplicationConfigurationScopeProvider extends AbstractApplicationConfigurationScopeProvider { + + private val language = ApplicationConfigurationPackage.eINSTANCE + + override getScope(EObject context, EReference reference) { + val document = EcoreUtil2.getContainerOfType(context,ConfigurationScript) + if(context instanceof MetamodelElement) { + context.scopeForMetamodelElement(reference,document) + } else if(context instanceof MetamodelSpecification) { + context.scopeForMetamodelSpecification(reference,document) + } else if(context instanceof AllPackageEntry){ + context.scopeForAllPackageEntry(reference,document) + } else { + return super.getScope(context,reference) + } + } + + private def allEPackages(ConfigurationScript document) { + return document.imports.filter(EPackageImport).map[it.importedPackage].filterNull + } + + private def allEClassifiers(ConfigurationScript document) { + document.allEPackages.map[EClassifiers].flatten + } + + protected def scopeForMetamodelElement(MetamodelElement context, EReference reference, ConfigurationScript document) { + if(reference === language.metamodelEntry_Package) { + if(context.classifier !== null) { + return Scopes.scopeFor(#[context.classifier.EPackage]) + } else { + return Scopes.scopeFor(document.allEPackages) + } + } if(reference === language.metamodelElement_Classifier) { + if(context.package != null) { + return Scopes.scopeFor(context.package.EClassifiers) + } else { + return Scopes.scopeFor(document.allEClassifiers) + } + } if (reference === language.metamodelElement_Feature) { + val referredClassifier = context.classifier + if(referredClassifier instanceof EClass) { + return Scopes.scopeFor(referredClassifier.EAllStructuralFeatures) + } else if(referredClassifier instanceof EEnum) { + return Scopes.scopeFor(referredClassifier.ELiterals) + } else { + super.getScope(context,reference) + } + } + } + + protected def scopeForMetamodelSpecification(MetamodelSpecification context, EReference reference, ConfigurationScript document) { + if(reference === language.metamodelEntry_Package) { + return Scopes.scopeFor(document.allEPackages) + } else if(reference ===language.metamodelElement_Classifier) { + return Scopes.scopeFor(document.allEClassifiers) + } + } + + protected def scopeForAllPackageEntry(AllPackageEntry context, EReference reference, ConfigurationScript document) { + if(reference === language.metamodelEntry_Package) { + return Scopes.scopeFor(document.allEPackages) + } else if(reference === language.metamodelEntry_Package) { + if(context.package === null) { + return Scopes.scopeFor(document.allEClassifiers) + } else { + return Scopes.scopeFor(context.package.EClassifiers) + } + } + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/validation/ApplicationConfigurationValidator.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/validation/ApplicationConfigurationValidator.xtend new file mode 100644 index 00000000..1024cb19 --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/validation/ApplicationConfigurationValidator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.10.0 + */ +package hu.bme.mit.inf.dslreasoner.application.validation + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +class ApplicationConfigurationValidator extends AbstractApplicationConfigurationValidator { + +// public static val INVALID_NAME = 'invalidName' +// +// @Check +// def checkGreetingStartsWithCapital(Greeting greeting) { +// if (!Character.isUpperCase(greeting.name.charAt(0))) { +// warning('Name should start with a capital', +// ApplicationConfigurationPackage.Literals.GREETING__NAME, +// INVALID_NAME) +// } +// } + +} -- cgit v1.2.3-54-g00ecf