1 files changed, 112 insertions, 12 deletions
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
index 8c064cd3..6e725086 100644
--- 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
@@ -1,28 +1,128 @@
 package hu.bme.mit.inf.dslreasoner.application.execution
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry
 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification
-import hu.bme.mit.inf.dslreasoner.application.execution.util.VQLParser
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport
-import java.util.LinkedHashMap
+import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
-import org.eclipse.emf.ecore.resource.ResourceSet
+import java.util.HashMap
+import java.util.LinkedHashSet
+import java.util.List
+import java.util.Set
+import org.eclipse.emf.ecore.EClass
+import org.eclipse.emf.ecore.EPackage
+import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel
+import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder
+import org.eclipse.viatra.query.patternlanguage.patternLanguage.Pattern
+import org.eclipse.viatra.query.patternlanguage.patternLanguage.PatternCompositionConstraint
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.xtext.EcoreUtil2
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class QueryLoader {
-        val parser = new VQLParser
+        //val parser = new VQLParser
+        val builder = new SpecificationBuilder
        
-        def loadQueries(PatternSpecification specification, ResourceSet rs, Context context) {
+        def loadQueries(PatternSpecification specification) {
-                val uris = specification.entries.map[path].toList
+                val patterns = new LinkedHashSet
-                val models = parser.parse(uris,rs,context)
                
-                val res = new LinkedHashMap
+                for(entry: specification.entries) {
-                for(entry : specification.entries) {
+                        patterns += getPatterns(entry)
-                        res.put(entry,entry.path.lookup(models))
                }
                
-                return res
+                val allConcernedPatterns = patterns.allReferredPatterns
+                val pattern2Specification = allConcernedPatterns.translatePatterns()
+                
+                val List<IQuerySpecification<?>> patternsToTranslate =
+                        pattern2Specification.values.toList
+                val Set<IQuerySpecification<?>> validationPatterns =
+                        patterns.filter[it.annotations.exists[it.name.equals("Constraint")]]
+                        .map[lookup(pattern2Specification)]
+                        .toSet
+                val derivedFeatures = calculateDerivedFeatures(patterns.referredEcoreModels,patterns.map[it.lookup(pattern2Specification)])
+                
+                return new ViatraQuerySetDescriptor(
+                        patternsToTranslate,
+                        validationPatterns,
+                        derivedFeatures
+                ) -> allConcernedPatterns
        }
        
-        def pruneQueries(PatternSpecification specification, ResourceSet rs, Context context) {
+        def dispatch List<Pattern> getPatterns(AllPatternEntry entry) {
+                val excluded = entry.exclusuion.map[getPatterns]
+                val referredPatternModels = allPatternsWithSamePackage(entry,entry.package as PatternModel).toSet
+                val patterns = referredPatternModels.map[patterns].flatten
+                return patterns.filter[!excluded.contains(it)].toList
+        }
+        
+        def dispatch List<Pattern> getPatterns(PatternElement entry) {
+                return #[entry.pattern]
+        }
+        
+        def private allPatternsWithSamePackage(PatternEntry entry, PatternModel model) {
+                val packageURI = model.packageName
+                val document = EcoreUtil2.getContainerOfType(entry,ConfigurationScript)
+                val viatraImportsWithSamePackage = document.imports
+                        .filter(ViatraImport)
+                        .map[it.importedViatra]
+                        .filterNull
+                        .filter[packageName.equals(packageURI)]
+                return viatraImportsWithSamePackage
+        }
+        
+        /**
+         * Adds all referred patterns to a given set of patterns.
+         */
+        def private Set<Pattern> allReferredPatterns(Set<Pattern> patterns) {
+                val res = new LinkedHashSet
+                res+=patterns
                
+                var boolean changed
+                do{
+                        changed = false
+                        val newElements =  res.map[directlyReferredPatterns].flatten.filter[!res.contains(it)]
+                        if(!newElements.empty) {
+                                changed = true
+                                res.addAll(newElements)
+                        }
+                } while(changed)
+                
+                return res
+        }
+        
+        def private directlyReferredPatterns(Pattern pattern) {
+                return pattern
+                        .bodies
+                        .map[constraints]
+                        .flatten
+                        .filter(PatternCompositionConstraint)
+                        .map[call.patternRef].toSet
+        }
+        
+        def private referredEcoreModels(Set<Pattern> patterns) {
+                patterns.map[eContainer as PatternModel].map[it.importPackages.packageImport.map[it.EPackage].filterNull].flatten.toSet
+        }
+        
+        def private translatePatterns(Set<Pattern> xtextPattern) {
+                xtextPattern.toInvertedMap[builder.getOrCreateSpecification(it) as IQuerySpecification<?>]
+        }
+        
+        def private calculateDerivedFeatures(Set<EPackage> packages, Iterable<IQuerySpecification<?>> patterns) {
+                val features = packages.map[EClassifiers].flatten.filter(EClass).map[it.EStructuralFeatures].flatten
+                val res = new HashMap
+                for(feature : features) {
+                        val QBFAnnotation = feature.EAnnotations.filter[it.source.equals("org.eclipse.viatra.query.querybasedfeature")].head
+                        if(QBFAnnotation !== null) {
+                                val targetFQN = QBFAnnotation.details.get("patternFQN")
+                                val referredPattern = patterns.filter[it.fullyQualifiedName.equals(targetFQN)].head
+                                if(referredPattern!== null) {
+                                        res.put(referredPattern, feature)
+                                }
+                        }
+                }
+                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/QueryLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend index 8c064cd3..6e725086 100644 --- 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
@@ -1,28 +1,128 @@
1	package hu.bme.mit.inf.dslreasoner.application.execution	1	package hu.bme.mit.inf.dslreasoner.application.execution
2		2
		3	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry
		4	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript
		5	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement
		6	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry
3	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification	7	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification
4	import hu.bme.mit.inf.dslreasoner.application.execution.util.VQLParser	8	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport
5	import java.util.LinkedHashMap	9	import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
6	import org.eclipse.emf.ecore.resource.ResourceSet	10	import java.util.HashMap
		11	import java.util.LinkedHashSet
		12	import java.util.List
		13	import java.util.Set
		14	import org.eclipse.emf.ecore.EClass
		15	import org.eclipse.emf.ecore.EPackage
		16	import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel
		17	import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder
		18	import org.eclipse.viatra.query.patternlanguage.patternLanguage.Pattern
		19	import org.eclipse.viatra.query.patternlanguage.patternLanguage.PatternCompositionConstraint
		20	import org.eclipse.viatra.query.runtime.api.IQuerySpecification
		21	import org.eclipse.xtext.EcoreUtil2
7		22
8	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*	23	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
9		24
10	class QueryLoader {	25	class QueryLoader {
11	val parser = new VQLParser	26	//val parser = new VQLParser
		27	val builder = new SpecificationBuilder
12		28
13	def loadQueries(PatternSpecification specification, ResourceSet rs, Context context) {	29	def loadQueries(PatternSpecification specification) {
14	val uris = specification.entries.map[path].toList	30	val patterns = new LinkedHashSet
15	val models = parser.parse(uris,rs,context)
16		31
17	val res = new LinkedHashMap	32	for(entry: specification.entries) {
18	for(entry : specification.entries) {	33	patterns += getPatterns(entry)
19	res.put(entry,entry.path.lookup(models))
20	}	34	}
21		35
22	return res	36	val allConcernedPatterns = patterns.allReferredPatterns
		37	val pattern2Specification = allConcernedPatterns.translatePatterns()
		38
		39	val List<IQuerySpecification<?>> patternsToTranslate =
		40	pattern2Specification.values.toList
		41	val Set<IQuerySpecification<?>> validationPatterns =
		42	patterns.filter[it.annotations.exists[it.name.equals("Constraint")]]
		43	.map[lookup(pattern2Specification)]
		44	.toSet
		45	val derivedFeatures = calculateDerivedFeatures(patterns.referredEcoreModels,patterns.map[it.lookup(pattern2Specification)])
		46
		47	return new ViatraQuerySetDescriptor(
		48	patternsToTranslate,
		49	validationPatterns,
		50	derivedFeatures
		51	) -> allConcernedPatterns
23	}	52	}
24		53
25	def pruneQueries(PatternSpecification specification, ResourceSet rs, Context context) {	54	def dispatch List<Pattern> getPatterns(AllPatternEntry entry) {
		55	val excluded = entry.exclusuion.map[getPatterns]
		56	val referredPatternModels = allPatternsWithSamePackage(entry,entry.package as PatternModel).toSet
		57	val patterns = referredPatternModels.map[patterns].flatten
		58	return patterns.filter[!excluded.contains(it)].toList
		59	}
		60
		61	def dispatch List<Pattern> getPatterns(PatternElement entry) {
		62	return #[entry.pattern]
		63	}
		64
		65	def private allPatternsWithSamePackage(PatternEntry entry, PatternModel model) {
		66	val packageURI = model.packageName
		67	val document = EcoreUtil2.getContainerOfType(entry,ConfigurationScript)
		68	val viatraImportsWithSamePackage = document.imports
		69	.filter(ViatraImport)
		70	.map[it.importedViatra]
		71	.filterNull
		72	.filter[packageName.equals(packageURI)]
		73	return viatraImportsWithSamePackage
		74	}
		75
		76	/**
		77	* Adds all referred patterns to a given set of patterns.
		78	*/
		79	def private Set<Pattern> allReferredPatterns(Set<Pattern> patterns) {
		80	val res = new LinkedHashSet
		81	res+=patterns
26		82
		83	var boolean changed
		84	do{
		85	changed = false
		86	val newElements = res.map[directlyReferredPatterns].flatten.filter[!res.contains(it)]
		87	if(!newElements.empty) {
		88	changed = true
		89	res.addAll(newElements)
		90	}
		91	} while(changed)
		92
		93	return res
		94	}
		95
		96	def private directlyReferredPatterns(Pattern pattern) {
		97	return pattern
		98	.bodies
		99	.map[constraints]
		100	.flatten
		101	.filter(PatternCompositionConstraint)
		102	.map[call.patternRef].toSet
		103	}
		104
		105	def private referredEcoreModels(Set<Pattern> patterns) {
		106	patterns.map[eContainer as PatternModel].map[it.importPackages.packageImport.map[it.EPackage].filterNull].flatten.toSet
		107	}
		108
		109	def private translatePatterns(Set<Pattern> xtextPattern) {
		110	xtextPattern.toInvertedMap[builder.getOrCreateSpecification(it) as IQuerySpecification<?>]
		111	}
		112
		113	def private calculateDerivedFeatures(Set<EPackage> packages, Iterable<IQuerySpecification<?>> patterns) {
		114	val features = packages.map[EClassifiers].flatten.filter(EClass).map[it.EStructuralFeatures].flatten
		115	val res = new HashMap
		116	for(feature : features) {
		117	val QBFAnnotation = feature.EAnnotations.filter[it.source.equals("org.eclipse.viatra.query.querybasedfeature")].head
		118	if(QBFAnnotation !== null) {
		119	val targetFQN = QBFAnnotation.details.get("patternFQN")
		120	val referredPattern = patterns.filter[it.fullyQualifiedName.equals(targetFQN)].head
		121	if(referredPattern!== null) {
		122	res.put(referredPattern, feature)
		123	}
		124	}
		125	}
		126	return res
27	}	127	}
28	} \ No newline at end of file	128	} \ No newline at end of file