diff options
author | OszkarSemerath <oszka@SEMERATH-LAPTOP> | 2018-01-13 19:33:26 +0100 |
---|---|---|
committer | OszkarSemerath <oszka@SEMERATH-LAPTOP> | 2018-01-13 19:33:26 +0100 |
commit | 7e50434905cbb7f5d03636033b698e17a9075e9d (patch) | |
tree | 10e0968c20ac55dae4f5dc6077f39cf9947e3cb9 /Application/hu.bme.mit.inf.dslreasoner.application/src | |
parent | Test and measurement runners (diff) | |
download | VIATRA-Generator-7e50434905cbb7f5d03636033b698e17a9075e9d.tar.gz VIATRA-Generator-7e50434905cbb7f5d03636033b698e17a9075e9d.tar.zst VIATRA-Generator-7e50434905cbb7f5d03636033b698e17a9075e9d.zip |
Initial commit of the configuration language and application
Diffstat (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src')
15 files changed, 882 insertions, 0 deletions
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 @@ | |||
1 | grammar hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration with org.eclipse.xtext.common.Terminals | ||
2 | |||
3 | import "http://www.eclipse.org/emf/2002/Ecore" as ecore | ||
4 | import "http://www.eclipse.org/viatra/query/patternlanguage/PatternLanguage" as viatra | ||
5 | generate applicationConfiguration "http://www.bme.hu/mit/inf/dslreasoner/application/ApplicationConfiguration" | ||
6 | |||
7 | ConfigurationScript: | ||
8 | (imports += Import)* | ||
9 | (commands += Command)* | ||
10 | ; | ||
11 | |||
12 | Command : | ||
13 | Declaration | ||
14 | //| Task | ||
15 | ; | ||
16 | Declaration : | ||
17 | // FileDeclaration | | ||
18 | MetamodelDeclaration | ||
19 | // | PartialModelDeclaration | ||
20 | // | GraphPatternDeclaration | ||
21 | // | SolverConfig | ||
22 | ; | ||
23 | |||
24 | /////////////////////////////////////////////////// | ||
25 | // Imports | ||
26 | /////////////////////////////////////////////////// | ||
27 | |||
28 | Import: EPackageImport | ViatraImport; | ||
29 | |||
30 | EPackageImport: "import" "epackage" importedPackage=[ecore::EPackage|STRING]; | ||
31 | ViatraImport: "import" "viatra" importedViatra=[viatra::PatternModel|STRING]; | ||
32 | |||
33 | /////////////////////////////////////////////////// | ||
34 | // Files and Folders | ||
35 | /////////////////////////////////////////////////// | ||
36 | /* | ||
37 | FileSpecification: path = STRING; | ||
38 | FileDeclaration: 'file' name = ID '=' specification = FileSpecification; | ||
39 | |||
40 | FileReference: referred = [FileDeclaration]; | ||
41 | File: FileSpecification | FileReference; | ||
42 | */ | ||
43 | /////////////////////////////////////////////////// | ||
44 | // Metamodel | ||
45 | /////////////////////////////////////////////////// | ||
46 | |||
47 | MetamodelSpecification: '{' (entries += MetamodelEntry) (',' entries += MetamodelEntry)* '}'; | ||
48 | MetamodelEntry: MetamodelElement | AllPackageEntry; | ||
49 | AllPackageEntry: "package" package=[ecore::EPackage] ("excluding" '{'exclusion +=MetamodelElement (',' exclusion +=MetamodelElement)*'}')?; | ||
50 | MetamodelElement: (package=[ecore::EPackage] '::')? classifier = [ecore::EClassifier] ('.' feature= [ecore::ENamedElement])?; | ||
51 | |||
52 | MetamodelDeclaration: 'metamodel' name = ID specification = MetamodelSpecification; | ||
53 | MetamodelReference: referred = [MetamodelDeclaration]; | ||
54 | Metamodel: MetamodelReference | MetamodelSpecification; | ||
55 | |||
56 | /////////////////////////////////////////////////// | ||
57 | // Partial Model | ||
58 | /////////////////////////////////////////////////// | ||
59 | /* | ||
60 | PartialModelEntry: path = File; | ||
61 | PartialModelSpecification: entry += PartialModelEntry ('+' entry += PartialModelEntry)*; | ||
62 | PartialModelDeclaration: 'partial-model' name = ID '=' specification = PartialModelSpecification; | ||
63 | PartialModelReference : referred = [PartialModelDeclaration]; | ||
64 | PartialModel: PartialModelSpecification | PartialModelReference; | ||
65 | */ | ||
66 | /////////////////////////////////////////////////// | ||
67 | // Patterns | ||
68 | /////////////////////////////////////////////////// | ||
69 | /* | ||
70 | PatternSpecification: '{' entries += PatternEntry (',' entries += PatternEntry)* '}'; | ||
71 | PatternEntry: PatternElement | AllPatternEntry; | ||
72 | AllPatternEntry: package = [viatra::PatternModel] ('excluding' '{' exclusuion += PatternElement (',' exclusuion += PatternElement)* '}')?; | ||
73 | PatternElement: pattern = [viatra::Pattern]; | ||
74 | |||
75 | GraphPatternDeclaration: 'patterns' name = ID specification = PatternSpecification; | ||
76 | GraphPatternReference: referred = [GraphPatternDeclaration]; | ||
77 | GraphPattern: GraphPatternReference|PatternSpecification; | ||
78 | */ | ||
79 | /////////////////////////////////////////////////// | ||
80 | // SolverConfig | ||
81 | /////////////////////////////////////////////////// | ||
82 | /* | ||
83 | SolverConfig : SMTSolverConfig | AlloySolverConfig | ViatraSolverConfig; | ||
84 | |||
85 | SMTSolverConfig: | ||
86 | 'smt-solver-config' name = ID '{' | ||
87 | 'solver-path' '=' solverPath = File | ||
88 | '}' | ||
89 | ; | ||
90 | |||
91 | AlloySolverConfig: | ||
92 | 'alloy-solver-config' name = ID '{' | ||
93 | ('symmetry' '=' symmetry=INT)? | ||
94 | '}' | ||
95 | ; | ||
96 | |||
97 | ViatraSolverConfig: | ||
98 | 'viatra-solver-config' name = ID '{' | ||
99 | ('statecoding' '=' statecoding = ViatraStatecoder)? & | ||
100 | ('type-inferencing' '=' typeinferencing = ViatraTypeInferencing)? & | ||
101 | ('backtrack-chance' '=' backtrackChance = INT)? | ||
102 | '}' | ||
103 | ; | ||
104 | enum ViatraStatecoder: neighbourhood | identifier; | ||
105 | enum ViatraTypeInferencing: preliminary | online; | ||
106 | |||
107 | Solver: SMTSolver | AlloySolver | ViatraSolver; | ||
108 | |||
109 | SMTSolver: 'smt-solver' '(' (config = [SMTSolverConfig]) ')'; | ||
110 | AlloySolver: 'alloy-solver' {AlloySolver} '(' (config = [AlloySolverConfig]|'default') ')'; | ||
111 | ViatraSolver: 'viatra-solver' {ViatraSolver} '(' (config= [ViatraSolverConfig]|'default')')'; | ||
112 | |||
113 | Task: GenerationTask; | ||
114 | |||
115 | GenerationTask: 'generate' '{' | ||
116 | ('metamodel' '=' metamodel = Metamodel) & | ||
117 | ('partial-model' '=' partialModel = PartialModel)? & | ||
118 | ('patterns' '=' patterns = GraphPattern)? & | ||
119 | ('new-objects' '=' size = INT) & | ||
120 | ('number' '=' number= INT)? & | ||
121 | ('runs' '=' runs = INT)? | ||
122 | 'target-folder' '=' tagetFolder = File | ||
123 | 'debug-folder' '=' debugFolder = File | ||
124 | ('log' '=' targetLogFile = File)? | ||
125 | ('statistics' '=' targetStatisticsFile = File)? | ||
126 | '}' | ||
127 | ;*/ \ 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 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.10.0 | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.application | ||
5 | |||
6 | import hu.bme.mit.inf.dslreasoner.application.linking.ApplicationConfigurationLinkingService | ||
7 | import com.google.inject.Binder | ||
8 | import com.google.inject.multibindings.Multibinder | ||
9 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProviderInstance | ||
10 | import org.apache.log4j.Logger | ||
11 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProvider | ||
12 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.CompoundMetamodelProviderService | ||
13 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.MetamodelProviderService | ||
14 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.ResourceSetMetamodelProviderService | ||
15 | import org.eclipse.viatra.query.patternlanguage.emf.IGenmodelMappingLoader | ||
16 | import org.eclipse.viatra.query.patternlanguage.emf.GenmodelExtensionLoader | ||
17 | |||
18 | /** | ||
19 | * Use this class to register components to be used at runtime / without the Equinox extension registry. | ||
20 | */ | ||
21 | class ApplicationConfigurationRuntimeModule extends AbstractApplicationConfigurationRuntimeModule { | ||
22 | override bindILinkingService() { | ||
23 | ApplicationConfigurationLinkingService | ||
24 | } | ||
25 | |||
26 | def configureLoggerImplementation(Binder binder) { | ||
27 | binder.bind(Logger).toInstance(Logger.getLogger(ApplicationConfigurationRuntimeModule)) | ||
28 | } | ||
29 | |||
30 | def Class<? extends IMetamodelProvider> bindIMetamodelProvider() { | ||
31 | CompoundMetamodelProviderService | ||
32 | } | ||
33 | |||
34 | def configureMetamodelProviderInstance(Binder binder) { | ||
35 | val metamodelProviderBinder = Multibinder.newSetBinder(binder, IMetamodelProviderInstance) | ||
36 | metamodelProviderBinder.addBinding.to(MetamodelProviderService) | ||
37 | metamodelProviderBinder.addBinding.to(ResourceSetMetamodelProviderService) | ||
38 | } | ||
39 | |||
40 | def Class<? extends IGenmodelMappingLoader> bindIGenmodelMappingLoader() { | ||
41 | GenmodelExtensionLoader | ||
42 | } | ||
43 | } | ||
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 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.10.0 | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.application | ||
5 | |||
6 | |||
7 | /** | ||
8 | * Initialization support for running Xtext languages without Equinox extension registry. | ||
9 | */ | ||
10 | class ApplicationConfigurationStandaloneSetup extends ApplicationConfigurationStandaloneSetupGenerated { | ||
11 | |||
12 | def static void doSetup() { | ||
13 | new ApplicationConfigurationStandaloneSetup().createInjectorAndDoEMFRegistration() | ||
14 | } | ||
15 | } | ||
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 @@ | |||
1 | module hu.bme.mit.inf.dslreasoner.application.GenerateApplicationConfiguration | ||
2 | |||
3 | import org.eclipse.xtext.xtext.generator.* | ||
4 | import org.eclipse.xtext.xtext.generator.model.project.* | ||
5 | |||
6 | var rootPath = ".." | ||
7 | |||
8 | Workflow { | ||
9 | |||
10 | component = XtextGenerator { | ||
11 | |||
12 | configuration = { | ||
13 | project = StandardProjectConfig { | ||
14 | |||
15 | baseName = "hu.bme.mit.inf.dslreasoner.application" | ||
16 | rootPath = rootPath | ||
17 | |||
18 | eclipsePlugin = { | ||
19 | enabled = true | ||
20 | } | ||
21 | createEclipseMetaData = true | ||
22 | |||
23 | } | ||
24 | code = { | ||
25 | encoding = "UTF-8" | ||
26 | fileHeader = "/*\n * generated by Xtext \${version}\n */" | ||
27 | |||
28 | } | ||
29 | } | ||
30 | language = StandardLanguage { | ||
31 | name = "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration" | ||
32 | referencedResource = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" | ||
33 | referencedResource = "platform:/resource/org.eclipse.viatra.query.patternlanguage/model/generated/PatternLanguage.genmodel" | ||
34 | fileExtensions = "vsconfig" | ||
35 | serializer = { | ||
36 | generateStub = false | ||
37 | } | ||
38 | validator = { | ||
39 | // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" | ||
40 | } | ||
41 | } | ||
42 | } | ||
43 | } | ||
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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | import java.io.OutputStream | ||
4 | import java.util.LinkedList | ||
5 | import java.util.List | ||
6 | import java.io.FileWriter | ||
7 | import org.eclipse.xtend.lib.annotations.Accessors | ||
8 | |||
9 | class Context { | ||
10 | @Accessors(PUBLIC_GETTER,PUBLIC_SETTER) | ||
11 | var boolean printToConsole = true | ||
12 | |||
13 | def writeError(Object object) { | ||
14 | if(printToConsole) { | ||
15 | println(object) | ||
16 | } | ||
17 | } | ||
18 | } \ 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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | import org.apache.log4j.Logger | ||
4 | import org.apache.log4j.LogManager | ||
5 | import org.apache.log4j.Level | ||
6 | import java.io.PrintStream | ||
7 | import java.io.OutputStream | ||
8 | import java.io.BufferedWriter | ||
9 | import java.io.Writer | ||
10 | |||
11 | class ExecuteScript { | ||
12 | def static void main(String[] args) { | ||
13 | val Logger logger = LogManager.getLogger(ExecuteScript); | ||
14 | logger.level = Level::DEBUG | ||
15 | |||
16 | println() | ||
17 | System.out.println("asd") | ||
18 | |||
19 | logger.debug("debug") | ||
20 | logger.info("info") | ||
21 | logger.warn("warning") | ||
22 | logger.error("error") | ||
23 | logger.fatal("fatal") | ||
24 | } | ||
25 | } \ 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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript | ||
4 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.Task | ||
5 | import java.util.HashMap | ||
6 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask | ||
7 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.Metamodel | ||
8 | import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace | ||
9 | import java.util.List | ||
10 | import org.eclipse.emf.ecore.EClass | ||
11 | import org.eclipse.emf.ecore.EEnumLiteral | ||
12 | import org.eclipse.emf.ecore.EReference | ||
13 | import org.eclipse.emf.ecore.EEnum | ||
14 | import org.eclipse.emf.ecore.EAttribute | ||
15 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor | ||
16 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | ||
17 | import org.eclipse.emf.ecore.EObject | ||
18 | import java.util.LinkedHashMap | ||
19 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor | ||
20 | import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic | ||
21 | import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic | ||
22 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic | ||
23 | import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration | ||
24 | import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration | ||
25 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration | ||
26 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod | ||
27 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy | ||
28 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner | ||
29 | import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult | ||
30 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
31 | import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult | ||
32 | import org.eclipse.emf.ecore.resource.Resource | ||
33 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl | ||
34 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml | ||
35 | import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolverConfiguration | ||
36 | import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolver | ||
37 | import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore | ||
38 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner | ||
39 | import java.util.LinkedList | ||
40 | import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisation | ||
41 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicStructureBuilder | ||
42 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
43 | import org.eclipse.emf.ecore.util.EcoreUtil | ||
44 | import org.eclipse.xtext.EcoreUtil2 | ||
45 | import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl | ||
46 | import org.eclipse.emf.ecore.resource.ResourceSet | ||
47 | import org.eclipse.emf.common.util.URI | ||
48 | import org.eclipse.emf.ecore.EPackage | ||
49 | |||
50 | class Executor { | ||
51 | public def void execute(ConfigurationScript configurationScript) { | ||
52 | val tasks = configurationScript.commands.filter(Task) | ||
53 | val numberOfModels = tasks.map[it.calculateTaskSteps].reduce[p1, p2|p1+p2] | ||
54 | } | ||
55 | |||
56 | def private dispatch calculateTaskSteps(Task task) { | ||
57 | throw new UnsupportedOperationException() | ||
58 | } | ||
59 | def private dispatch calculateTaskSteps(GenerationTask task) { | ||
60 | return task.number * task.runs | ||
61 | } | ||
62 | |||
63 | def private dispatch executeTask(Task task) { | ||
64 | throw new UnsupportedOperationException() | ||
65 | } | ||
66 | def private dispatch executeTask(GenerationTask generationTask) { | ||
67 | val metamodel = generationTask.metamodel | ||
68 | if(metamodel != null) { | ||
69 | |||
70 | } | ||
71 | } | ||
72 | |||
73 | def protected loadPackage(ResourceSet rs, String path) { | ||
74 | var EObject content = null | ||
75 | |||
76 | try { | ||
77 | val resource = rs.getResource(URI.createURI(path),true) | ||
78 | content = resource.contents.get(0) | ||
79 | } catch(IllegalArgumentException e) { | ||
80 | return null | ||
81 | } catch(RuntimeException e) { | ||
82 | return null | ||
83 | } | ||
84 | |||
85 | if(content instanceof EPackage) { | ||
86 | |||
87 | } else return null | ||
88 | } | ||
89 | |||
90 | def loadPatternModel(ResourceSet rs, String path) { | ||
91 | var model = null | ||
92 | |||
93 | |||
94 | } | ||
95 | } | ||
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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassElement | ||
4 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FeatureElement | ||
5 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry | ||
6 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification | ||
7 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor | ||
8 | import java.util.ArrayList | ||
9 | import java.util.HashMap | ||
10 | import java.util.LinkedList | ||
11 | import java.util.List | ||
12 | import java.util.Map | ||
13 | import java.util.Set | ||
14 | import org.eclipse.emf.common.util.URI | ||
15 | import org.eclipse.emf.ecore.EAttribute | ||
16 | import org.eclipse.emf.ecore.EClass | ||
17 | import org.eclipse.emf.ecore.EDataType | ||
18 | import org.eclipse.emf.ecore.EEnum | ||
19 | import org.eclipse.emf.ecore.EEnumLiteral | ||
20 | import org.eclipse.emf.ecore.ENamedElement | ||
21 | import org.eclipse.emf.ecore.EPackage | ||
22 | import org.eclipse.emf.ecore.EReference | ||
23 | import org.eclipse.emf.ecore.EcorePackage | ||
24 | import org.eclipse.emf.ecore.resource.Resource | ||
25 | import org.eclipse.emf.ecore.resource.ResourceSet | ||
26 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl | ||
27 | import org.eclipse.xtend.lib.annotations.Data | ||
28 | |||
29 | @Data | ||
30 | class Metamodel { | ||
31 | List<EPackage> packages | ||
32 | EcoreMetamodelDescriptor descriptor | ||
33 | } | ||
34 | |||
35 | class MetamodelLoader { | ||
36 | |||
37 | def private static init() { | ||
38 | EcorePackage.eINSTANCE.EClass | ||
39 | Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("ecore",new XMIResourceFactoryImpl) | ||
40 | } | ||
41 | |||
42 | public new() { init } | ||
43 | |||
44 | def loadMetamodel(List<String> specification, ResourceSet rs, Context context) { | ||
45 | |||
46 | } | ||
47 | |||
48 | def loadMetamodel(MetamodelSpecification specification, ResourceSet rs, Context context) { | ||
49 | val Map<MetamodelEntry,List<EPackage>> entry2Packages = new HashMap | ||
50 | |||
51 | for(entry : specification.entries) { | ||
52 | val packagesInEntry = entry.path.path.loadPackageFromPath(rs,context) | ||
53 | entry2Packages.put(entry,packagesInEntry) | ||
54 | } | ||
55 | |||
56 | return entry2Packages | ||
57 | } | ||
58 | |||
59 | public def pruneMetamodel(Map<MetamodelEntry,List<EPackage>> specification, ResourceSet rs, Context context) { | ||
60 | val List<EClass> classes = new LinkedList | ||
61 | val List<EEnum> enums = new LinkedList | ||
62 | val List<EEnumLiteral> literals = new LinkedList | ||
63 | val List<EReference> references = new LinkedList | ||
64 | val List<EAttribute> attributes = new LinkedList | ||
65 | |||
66 | |||
67 | /** Add all included types */ | ||
68 | for(entry : specification.entrySet) { | ||
69 | val metamodelEntry = entry.key | ||
70 | val packages = entry.value | ||
71 | |||
72 | /** Excluted types */ | ||
73 | val excludedTypeNames = metamodelEntry.excluding.filter(ClassElement).map[name].toSet | ||
74 | /** Excluded features */ | ||
75 | val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet | ||
76 | |||
77 | /** Load the types */ | ||
78 | for(package : packages) { | ||
79 | for(class : package.EClassifiers.filter(EClass)) { | ||
80 | classes.addIfNotExcluded(class,excludedTypeNames) | ||
81 | } | ||
82 | for(enum : package.EClassifiers.filter(EEnum)) { | ||
83 | val added = enums.addIfNotExcluded(enum,excludedTypeNames) | ||
84 | if(added) { | ||
85 | for(literal : enum.ELiterals) { | ||
86 | literals.addIfNotExcluded(literal,enum,excludedFeatureNames) | ||
87 | } | ||
88 | } | ||
89 | } | ||
90 | } | ||
91 | } | ||
92 | |||
93 | /** Add all included references and attributes*/ | ||
94 | for(entry : specification.entrySet) { | ||
95 | val metamodelEntry = entry.key | ||
96 | val packages = entry.value | ||
97 | |||
98 | /** Excluded features */ | ||
99 | val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet | ||
100 | |||
101 | /** See if type is included */ | ||
102 | for(package : packages) { | ||
103 | for(class : package.EClassifiers.filter(EClass)) { | ||
104 | if(classes.contains(class)) { | ||
105 | for(reference : class.EReferences) { | ||
106 | if(classes.contains(reference.EType)) { | ||
107 | references.addIfNotExcluded(reference,class,excludedFeatureNames) | ||
108 | } | ||
109 | } | ||
110 | for(attribute : class.EAttributes) { | ||
111 | val type = attribute.EType | ||
112 | if(type instanceof EEnum) { | ||
113 | if(enums.contains(type)) { | ||
114 | attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) | ||
115 | } else if(type == EcorePackage.Literals) { | ||
116 | if(enums.contains(type)) { | ||
117 | attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) | ||
118 | } | ||
119 | } | ||
120 | } else if(supportedEDataType(type as EDataType)) { | ||
121 | attributes.addIfNotExcluded(attribute,class,excludedFeatureNames) | ||
122 | } | ||
123 | } | ||
124 | } | ||
125 | } | ||
126 | } | ||
127 | } | ||
128 | } | ||
129 | |||
130 | private def supportedEDataType(EDataType dataType) { | ||
131 | val extension l = EcorePackage.eINSTANCE | ||
132 | return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType) | ||
133 | } | ||
134 | |||
135 | private def <T extends ENamedElement> addIfNotExcluded( | ||
136 | List<T> target, | ||
137 | T element, | ||
138 | Set<String> excluded) | ||
139 | { | ||
140 | if(excluded.contains(element.name)) { | ||
141 | target += element | ||
142 | return true | ||
143 | } else { | ||
144 | return false | ||
145 | } | ||
146 | } | ||
147 | private def <T1 extends ENamedElement> addIfNotExcluded( | ||
148 | List<T1> target, | ||
149 | T1 element, | ||
150 | ENamedElement container, | ||
151 | Set<Pair<String,String>> excluded) | ||
152 | { | ||
153 | val pair = (container.name) -> (element.name) | ||
154 | |||
155 | if(excluded.contains(pair)) { | ||
156 | target += element | ||
157 | } | ||
158 | } | ||
159 | |||
160 | private def List<EPackage> loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException { | ||
161 | var Resource resource; | ||
162 | try{ | ||
163 | resource = rs.getResource(URI.createURI(path),true) | ||
164 | } catch(RuntimeException e) { | ||
165 | context.writeError('''Unable to load EPackage: Error in path "«path»"!''') | ||
166 | return #[] | ||
167 | } | ||
168 | val res = new ArrayList<EPackage>(resource.contents.size) | ||
169 | for(content: resource.contents) { | ||
170 | if(content instanceof EPackage) { | ||
171 | res += content | ||
172 | } else { | ||
173 | context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''') | ||
174 | } | ||
175 | } | ||
176 | return res | ||
177 | } | ||
178 | } \ 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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | class ModelLoader { | ||
4 | //def loadMetamodels()7 | ||
5 | // val List<EClass> classes = new LinkedList | ||
6 | // val List<EReference> references = new LinkedList | ||
7 | // val List<EAttribute> attributes = new LinkedList | ||
8 | // val List<EEnum> enums = new LinkedList | ||
9 | // val List<EEnumLiteral> literals = new LinkedList | ||
10 | // | ||
11 | } \ 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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification | ||
4 | import hu.bme.mit.inf.dslreasoner.application.execution.util.VQLParser | ||
5 | import java.util.LinkedHashMap | ||
6 | import org.eclipse.emf.ecore.resource.ResourceSet | ||
7 | |||
8 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
9 | |||
10 | class QueryLoader { | ||
11 | val parser = new VQLParser | ||
12 | |||
13 | def loadQueries(PatternSpecification specification, ResourceSet rs, Context context) { | ||
14 | val uris = specification.entries.map[path].toList | ||
15 | val models = parser.parse(uris,rs,context) | ||
16 | |||
17 | val res = new LinkedHashMap | ||
18 | for(entry : specification.entries) { | ||
19 | res.put(entry,entry.path.lookup(models)) | ||
20 | } | ||
21 | |||
22 | return res | ||
23 | } | ||
24 | |||
25 | def pruneQueries(PatternSpecification specification, ResourceSet rs, Context context) { | ||
26 | |||
27 | } | ||
28 | } \ 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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.execution.util | ||
2 | |||
3 | import com.google.inject.Guice | ||
4 | import com.google.inject.Injector | ||
5 | import com.google.inject.Module | ||
6 | import java.util.LinkedHashMap | ||
7 | import org.eclipse.emf.common.util.URI | ||
8 | import org.eclipse.emf.ecore.resource.Resource | ||
9 | import org.eclipse.emf.ecore.resource.ResourceSet | ||
10 | import org.eclipse.emf.ecore.util.EcoreUtil | ||
11 | import org.eclipse.viatra.query.patternlanguage.PatternLanguageStandaloneSetup | ||
12 | import org.eclipse.viatra.query.patternlanguage.annotations.ExtensionBasedAnnotationValidatorLoader | ||
13 | import org.eclipse.viatra.query.patternlanguage.annotations.IAnnotationValidatorLoader | ||
14 | import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageRuntimeModule | ||
15 | import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup | ||
16 | import org.eclipse.viatra.query.patternlanguage.emf.GenmodelExtensionLoader | ||
17 | import org.eclipse.viatra.query.patternlanguage.emf.IGenmodelMappingLoader | ||
18 | import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel | ||
19 | import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder | ||
20 | import org.eclipse.xtext.resource.XtextResourceSet | ||
21 | import hu.bme.mit.inf.dslreasoner.application.execution.Context | ||
22 | import java.util.List | ||
23 | import java.util.HashMap | ||
24 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
25 | |||
26 | class MyModule extends EMFPatternLanguageRuntimeModule implements Module { | ||
27 | def public Class<? extends IAnnotationValidatorLoader> bindAnnotationValidatorLoader() { | ||
28 | return typeof(ExtensionBasedAnnotationValidatorLoader); | ||
29 | } | ||
30 | def public Class<? extends IGenmodelMappingLoader> bindGenmodelMappingLoader() { | ||
31 | return typeof(GenmodelExtensionLoader); | ||
32 | } | ||
33 | } | ||
34 | |||
35 | class VQLParser { | ||
36 | val Injector injector; | ||
37 | val SpecificationBuilder builder = new SpecificationBuilder | ||
38 | |||
39 | new() { | ||
40 | PatternLanguageStandaloneSetup.doSetup | ||
41 | EMFPatternLanguageStandaloneSetup.doSetup; | ||
42 | |||
43 | injector = internalCreateInjector | ||
44 | } | ||
45 | |||
46 | def protected Injector internalCreateInjector() { | ||
47 | new EMFPatternLanguageStandaloneSetup().createInjectorAndDoEMFRegistration(); | ||
48 | val Module module = new MyModule | ||
49 | val newInjector = Guice.createInjector(module) | ||
50 | return newInjector; | ||
51 | } | ||
52 | |||
53 | public def createResourceSet() { | ||
54 | injector.getInstance(XtextResourceSet); | ||
55 | } | ||
56 | |||
57 | /** | ||
58 | * Load patterns in two steps: first, the pattern models are are loaded to a resource set, then | ||
59 | * the linked patterns are loaded validated and translated to a {@link IQuerySpecification} object. | ||
60 | * @returns uri -> (name -> pattern) | ||
61 | */ | ||
62 | public def parse(List<String> uris, ResourceSet resourceSet, Context context) { | ||
63 | val res = new LinkedHashMap | ||
64 | val uri2resource = new LinkedHashMap | ||
65 | |||
66 | for(uri : uris) { | ||
67 | var Resource resource | ||
68 | var PatternModel patternModel | ||
69 | try { | ||
70 | resource = resourceSet.getResource(URI.createURI(uri),true); | ||
71 | patternModel = resource.getContents().get(0) as PatternModel; | ||
72 | uri2resource.put(uri,patternModel) | ||
73 | } catch(RuntimeException e) { | ||
74 | context.writeError('''Unable to load patterns from "«uri»"!''') | ||
75 | } | ||
76 | } | ||
77 | |||
78 | for(entry : uri2resource.entrySet) { | ||
79 | val uri = entry.key | ||
80 | val model = entry.value | ||
81 | EcoreUtil.resolveAll(model.eResource) | ||
82 | model.eResource.validate(uri, context) | ||
83 | |||
84 | val map = new LinkedHashMap | ||
85 | for(pattern : model.patterns) { | ||
86 | val IQuerySpecification<?> querySpecification = (this.builder as SpecificationBuilder).getOrCreateSpecification(pattern) | ||
87 | map.put(querySpecification.fullyQualifiedName.split('.').last,querySpecification) | ||
88 | } | ||
89 | res.put(uri,map) | ||
90 | } | ||
91 | |||
92 | return res | ||
93 | } | ||
94 | |||
95 | def private validate(Resource resource, String URI, Context context) { | ||
96 | val errors = resource.errors | ||
97 | errors.forEach[context.writeError('''Error in loading pattern "«URI»": «it»''')] | ||
98 | } | ||
99 | } \ 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 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.10.0 | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.application.generator | ||
5 | |||
6 | import org.eclipse.emf.ecore.resource.Resource | ||
7 | import org.eclipse.xtext.generator.AbstractGenerator | ||
8 | import org.eclipse.xtext.generator.IFileSystemAccess2 | ||
9 | import org.eclipse.xtext.generator.IGeneratorContext | ||
10 | |||
11 | /** | ||
12 | * Generates code from your model files on save. | ||
13 | * | ||
14 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation | ||
15 | */ | ||
16 | class ApplicationConfigurationGenerator extends AbstractGenerator { | ||
17 | |||
18 | override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { | ||
19 | // fsa.generateFile('greetings.txt', 'People to greet: ' + | ||
20 | // resource.allContents | ||
21 | // .filter(typeof(Greeting)) | ||
22 | // .map[name] | ||
23 | // .join(', ')) | ||
24 | } | ||
25 | } | ||
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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.application.linking | ||
2 | |||
3 | import com.google.inject.Inject | ||
4 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage | ||
5 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport | ||
6 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport | ||
7 | import java.util.Collections | ||
8 | import java.util.Optional | ||
9 | import org.eclipse.emf.ecore.EObject | ||
10 | import org.eclipse.emf.ecore.EReference | ||
11 | import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProvider | ||
12 | import org.eclipse.xtext.conversion.IValueConverterService | ||
13 | import org.eclipse.xtext.conversion.ValueConverterException | ||
14 | import org.eclipse.xtext.linking.impl.DefaultLinkingService | ||
15 | import org.eclipse.xtext.nodemodel.ILeafNode | ||
16 | import org.eclipse.xtext.nodemodel.INode | ||
17 | |||
18 | class ApplicationConfigurationLinkingService extends DefaultLinkingService{ | ||
19 | |||
20 | //@Inject Logger logger | ||
21 | |||
22 | @Inject IValueConverterService valueConverterService | ||
23 | |||
24 | @Inject IMetamodelProvider metamodelProvider | ||
25 | |||
26 | public static extension ApplicationConfigurationPackage pac = ApplicationConfigurationPackage.eINSTANCE | ||
27 | |||
28 | override getLinkedObjects(EObject context, EReference ref, INode node) { | ||
29 | if(context instanceof EPackageImport) { | ||
30 | if(ref == EPackageImport_ImportedPackage && node instanceof ILeafNode) { | ||
31 | return getEPackage(context as EPackageImport, node as ILeafNode) | ||
32 | } | ||
33 | } else if(context instanceof ViatraImport) { | ||
34 | super.getLinkedObjects(context, ref, node) | ||
35 | } | ||
36 | return super.getLinkedObjects(context, ref, node) | ||
37 | } | ||
38 | |||
39 | private def getEPackage(EPackageImport packageImport, ILeafNode node) { | ||
40 | getMetamodelNsUri(node).flatMap [ uri | | ||
41 | Optional.ofNullable(metamodelProvider.loadEPackage(uri, packageImport.eResource.resourceSet)) | ||
42 | ].map [ ePackage | | ||
43 | Collections.singletonList(ePackage as EObject) | ||
44 | ].orElse(emptyList) | ||
45 | } | ||
46 | |||
47 | private def getMetamodelNsUri(ILeafNode node) { | ||
48 | try { | ||
49 | val convertedValue = valueConverterService.toValue(node.text, | ||
50 | linkingHelper.getRuleNameFrom(node.grammarElement), node) | ||
51 | Optional.of(convertedValue as String) | ||
52 | } catch (ValueConverterException e) { | ||
53 | Optional.empty | ||
54 | } | ||
55 | } | ||
56 | } \ 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 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.10.0 | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.application.scoping | ||
5 | |||
6 | import org.eclipse.emf.ecore.EObject | ||
7 | import org.eclipse.emf.ecore.EReference | ||
8 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement | ||
9 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage | ||
10 | import org.eclipse.xtext.EcoreUtil2 | ||
11 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript | ||
12 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport | ||
13 | import org.eclipse.xtext.scoping.Scopes | ||
14 | import org.eclipse.emf.ecore.EClass | ||
15 | import org.eclipse.emf.ecore.EEnum | ||
16 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification | ||
17 | import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry | ||
18 | |||
19 | /** | ||
20 | * This class contains custom scoping description. | ||
21 | * | ||
22 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping | ||
23 | * on how and when to use it. | ||
24 | */ | ||
25 | class ApplicationConfigurationScopeProvider extends AbstractApplicationConfigurationScopeProvider { | ||
26 | |||
27 | private val language = ApplicationConfigurationPackage.eINSTANCE | ||
28 | |||
29 | override getScope(EObject context, EReference reference) { | ||
30 | val document = EcoreUtil2.getContainerOfType(context,ConfigurationScript) | ||
31 | if(context instanceof MetamodelElement) { | ||
32 | context.scopeForMetamodelElement(reference,document) | ||
33 | } else if(context instanceof MetamodelSpecification) { | ||
34 | context.scopeForMetamodelSpecification(reference,document) | ||
35 | } else if(context instanceof AllPackageEntry){ | ||
36 | context.scopeForAllPackageEntry(reference,document) | ||
37 | } else { | ||
38 | return super.getScope(context,reference) | ||
39 | } | ||
40 | } | ||
41 | |||
42 | private def allEPackages(ConfigurationScript document) { | ||
43 | return document.imports.filter(EPackageImport).map[it.importedPackage].filterNull | ||
44 | } | ||
45 | |||
46 | private def allEClassifiers(ConfigurationScript document) { | ||
47 | document.allEPackages.map[EClassifiers].flatten | ||
48 | } | ||
49 | |||
50 | protected def scopeForMetamodelElement(MetamodelElement context, EReference reference, ConfigurationScript document) { | ||
51 | if(reference === language.metamodelEntry_Package) { | ||
52 | if(context.classifier !== null) { | ||
53 | return Scopes.scopeFor(#[context.classifier.EPackage]) | ||
54 | } else { | ||
55 | return Scopes.scopeFor(document.allEPackages) | ||
56 | } | ||
57 | } if(reference === language.metamodelElement_Classifier) { | ||
58 | if(context.package != null) { | ||
59 | return Scopes.scopeFor(context.package.EClassifiers) | ||
60 | } else { | ||
61 | return Scopes.scopeFor(document.allEClassifiers) | ||
62 | } | ||
63 | } if (reference === language.metamodelElement_Feature) { | ||
64 | val referredClassifier = context.classifier | ||
65 | if(referredClassifier instanceof EClass) { | ||
66 | return Scopes.scopeFor(referredClassifier.EAllStructuralFeatures) | ||
67 | } else if(referredClassifier instanceof EEnum) { | ||
68 | return Scopes.scopeFor(referredClassifier.ELiterals) | ||
69 | } else { | ||
70 | super.getScope(context,reference) | ||
71 | } | ||
72 | } | ||
73 | } | ||
74 | |||
75 | protected def scopeForMetamodelSpecification(MetamodelSpecification context, EReference reference, ConfigurationScript document) { | ||
76 | if(reference === language.metamodelEntry_Package) { | ||
77 | return Scopes.scopeFor(document.allEPackages) | ||
78 | } else if(reference ===language.metamodelElement_Classifier) { | ||
79 | return Scopes.scopeFor(document.allEClassifiers) | ||
80 | } | ||
81 | } | ||
82 | |||
83 | protected def scopeForAllPackageEntry(AllPackageEntry context, EReference reference, ConfigurationScript document) { | ||
84 | if(reference === language.metamodelEntry_Package) { | ||
85 | return Scopes.scopeFor(document.allEPackages) | ||
86 | } else if(reference === language.metamodelEntry_Package) { | ||
87 | if(context.package === null) { | ||
88 | return Scopes.scopeFor(document.allEClassifiers) | ||
89 | } else { | ||
90 | return Scopes.scopeFor(context.package.EClassifiers) | ||
91 | } | ||
92 | } | ||
93 | } | ||
94 | } | ||
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 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.10.0 | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.application.validation | ||
5 | |||
6 | |||
7 | /** | ||
8 | * This class contains custom validation rules. | ||
9 | * | ||
10 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation | ||
11 | */ | ||
12 | class ApplicationConfigurationValidator extends AbstractApplicationConfigurationValidator { | ||
13 | |||
14 | // public static val INVALID_NAME = 'invalidName' | ||
15 | // | ||
16 | // @Check | ||
17 | // def checkGreetingStartsWithCapital(Greeting greeting) { | ||
18 | // if (!Character.isUpperCase(greeting.name.charAt(0))) { | ||
19 | // warning('Name should start with a capital', | ||
20 | // ApplicationConfigurationPackage.Literals.GREETING__NAME, | ||
21 | // INVALID_NAME) | ||
22 | // } | ||
23 | // } | ||
24 | |||
25 | } | ||