adapted generator to the immutable model

Author: doczir

plugins/hu.bme.mit.incquery.localsearch.cpp/src/hu/bme/mit/incquery/localsearch/cpp/generator/LocalSearchCppGenerator.xtend

@@ -21,13 +21,15 @@ class LocalSearchCppGenerator {
 
 	def IGeneratorOutputProvider generate(String queryFileName, ResourceSet resourceSet, List<PQuery> queries) {
 
-		val query = new QueryStub(queryFileName)
-		query.addClasses(resourceSet.resources.map[allContents].concat.filter(EClass).filterNull.toSet)
+		val classes = resourceSet.resources.map[allContents].concat.filter(EClass).filterNull.toSet
 
 		val planCompiler = new PlanCompiler
-		queries.forEach[planCompiler.compilePlan(it, query)]
+		val patternStubs = queries.map[
+			planCompiler.compilePlan(it)
+		].flatten.toSet
 
-		generator.initialize(query)
+		val queryStub = new QueryStub(queryFileName, patternStubs, classes)
+		generator.initialize(queryStub)
 
 		return generator
 	}

plugins/hu.bme.mit.incquery.localsearch.cpp/src/hu/bme/mit/incquery/localsearch/cpp/generator/planner/POperationCompiler.xtend

@@ -1,6 +1,7 @@
 package hu.bme.mit.incquery.localsearch.cpp.generator.planner
 
-import com.google.common.base.CaseFormat
+import com.google.common.base.Optional
+import com.google.common.collect.Maps
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.CheckInstanceOfStub
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.CheckMultiNavigationStub
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.CheckSingleNavigationStub
@@ -9,8 +10,10 @@ import hu.bme.mit.incquery.localsearch.cpp.generator.model.ExtendMultiNavigation
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.ExtendSingleNavigationStub
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.MatchingFrameStub
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.PatternBodyStub
+import hu.bme.mit.incquery.localsearch.cpp.generator.model.SearchOperationStub
+import hu.bme.mit.incquery.localsearch.cpp.generator.model.TypeInfo
+import hu.bme.mit.incquery.localsearch.cpp.generator.model.VariableInfo
 import hu.bme.mit.incquery.localsearch.cpp.generator.planner.util.CompilerHelper
-import hu.bme.mit.incquery.localsearch.cpp.generator.planner.util.CompilerHelper.TypeMap
 import java.util.Map
 import java.util.Set
 import org.eclipse.emf.ecore.EReference
@@ -34,61 +37,47 @@ class POperationCompiler {
 
 	var Map<PVariable, Integer> variableMapping
 	var Map<PConstraint, Set<Integer>> variableBindings
-	var Map<PVariable, TypeMap> typeMapping
+	var Map<PVariable, TypeInfo> typeMapping
 
 	var MatchingFrameStub matchingFrame
-	var PatternBodyStub patternBodyStub
 
 
-	def void compile(SubPlan plan, PBody pBody, Set<PVariable> boundVariables, PatternBodyStub bodyStub) {
+	def compile(SubPlan plan, PBody pBody, Set<PVariable> boundVariables) {
 		variableMapping = CompilerHelper::createVariableMapping(plan)
 		typeMapping = CompilerHelper::createTypeMapping(plan)
 		variableBindings = CompilerHelper::cacheVariableBindings(plan, variableMapping, boundVariables.map[variableMapping.get(it)].toSet)
 
-		matchingFrame = getMatchingFrame(plan, pBody)
-		bodyStub.matchingFrame = matchingFrame
+		matchingFrame = getMatchingFrame(pBody)
 
-		patternBodyStub = bodyStub
-
-		CompilerHelper::createOperationsList(plan).forEach [
-			compile(variableMapping)
-		]
-		return
+		val searchOperations = CompilerHelper::createOperationsList(plan)
+			.map[compile]
+			.flatten
+			.toList
+		return new PatternBodyStub(pBody, matchingFrame, searchOperations)
 	}
 
-	private def getMatchingFrame(SubPlan plan, PBody pBody) {
+	private def getMatchingFrame(PBody pBody) {
 		if(frameMap.containsKey(pBody)) {
 			frameMap.get(pBody)
 		} else {
-			val tmpMatchingFrame = new MatchingFrameStub
-			frameMap.put(pBody, tmpMatchingFrame)
-			
-			
-			typeMapping.forEach [ 
-				tmpMatchingFrame.addVariable($0, $1, variableMapping.get($0))
-			]
-
-			plan.body.pattern.parameters.map[plan.body.getVariableByNameChecked(it.name)].forEach [
-				tmpMatchingFrame.setVariableKey(it)
-			]
-			
-			plan.body.pattern.parameters.forEach[
-				tmpMatchingFrame.mapParameterToVariable(it, plan.body.getVariableByNameChecked(it.name))
-			]
-			
-			tmpMatchingFrame
+			val variableToParameterMap = Maps::uniqueIndex(pBody.pattern.parameters) [pBody.getVariableByNameChecked(it.name)]
+			// don't pass this to anything else or evaluate it! (Lazy evaluation!!)
+			val variableInfos = pBody.allVariables.map[
+				new VariableInfo(Optional::fromNullable(variableToParameterMap.get(it)), it, typeMapping.get(it), variableMapping.get(it))
+			].toList
+			new MatchingFrameStub(variableInfos)
 		}
 	}
 
-	def compile(POperation pOperation, Map<PVariable, Integer> variableMapping) {
+	def compile(POperation pOperation) {
 		switch (pOperation) {
 			PApply: {
 				val pConstraint = pOperation.getPConstraint
 
 				if(pConstraint.allBound)
-					createCheck(pConstraint, variableMapping)
+					return createCheck(pConstraint)
 				else
-					createExtend(pConstraint, variableMapping)
+					return createExtend(pConstraint)
 
 			}
 			PStart: {
@@ -98,15 +87,17 @@ class POperationCompiler {
 			default: { // TODO: throw an error
 			}
 		}
+		return #[]
 	}
 
-	def dispatch void createCheck(TypeConstraint constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createCheck(TypeConstraint constraint) {
+		val operations = <SearchOperationStub>newArrayList
 		val inputKey = constraint.supplierKey
 
 		switch (inputKey) {
 			EClassTransitiveInstancesKey: {
 				val variable = constraint.getVariableInTuple(0)
-				patternBodyStub.addSearchOperation(new CheckInstanceOfStub(matchingFrame, variable, inputKey.wrappedKey))
+				operations += new CheckInstanceOfStub(matchingFrame, variable, inputKey.wrappedKey)
 			}
 			EStructuralFeatureInstancesKey: {
 				val src = constraint.getVariableInTuple(0)
@@ -116,26 +107,31 @@ class POperationCompiler {
 
 				switch (relationType) {
 					case relationType.isOneToOne:
-						patternBodyStub.addSearchOperation(new CheckSingleNavigationStub(matchingFrame, src, trg, inputKey.wrappedKey))
+						operations += new CheckSingleNavigationStub(matchingFrame, src, trg, inputKey.wrappedKey)
 					case relationType.isOneToMany:
-						patternBodyStub.addSearchOperation(new CheckMultiNavigationStub(matchingFrame, src, trg, inputKey.wrappedKey))
+						operations += new CheckMultiNavigationStub(matchingFrame, src, trg, inputKey.wrappedKey)
 				}
 			}
 		}
+		
+		return operations
 	}
 
 //	def dispatch createCheck(CheckPConstraint constraint, Map<PVariable, Integer> variableMapping, String patternName) {
 //		pattern.addSearchOperation(new CheckExpressionStub(matchingFrame, constraint.affectedVariables, constraint.expression))
 //	}
 
-	def dispatch void createCheck(ExportedParameter constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createCheck(ExportedParameter constraint) {
 		// nop
+		#[]
 	}
 
-	def dispatch void createCheck(PConstraint constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createCheck(PConstraint constraint) {
+		#[]
 	}
 
-	def dispatch void createExtend(TypeConstraint constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createExtend(TypeConstraint constraint) {
+		val operations = <SearchOperationStub>newArrayList
 		val inputKey = constraint.supplierKey
 
 		// TODO : this is wasteful
@@ -147,7 +143,7 @@ class POperationCompiler {
 		switch (inputKey) {
 			EClassTransitiveInstancesKey: {
 				val variable = constraint.getVariableInTuple(0)
-				patternBodyStub.addSearchOperation(new ExtendInstanceOfStub(matchingFrame, variable, inputKey.wrappedKey))
+				operations += new ExtendInstanceOfStub(matchingFrame, variable, inputKey.wrappedKey)
 			}
 			EStructuralFeatureInstancesKey: {
 				var src = constraint.getVariableInTuple(0)
@@ -163,25 +159,28 @@ class POperationCompiler {
 					trg = tmp
 					key = (key as EReference).EOpposite
 				} else if (!fromBound && !toBound) {
-					patternBodyStub.addSearchOperation(new ExtendInstanceOfStub(matchingFrame, src, inputKey.wrappedKey.EContainingClass))					
+					operations += new ExtendInstanceOfStub(matchingFrame, src, inputKey.wrappedKey.EContainingClass)					
 				}
 
 				switch (key) {
 					case key.isOneToOne:
-						patternBodyStub.addSearchOperation(new ExtendSingleNavigationStub(matchingFrame, src, trg, key))
+						operations += new ExtendSingleNavigationStub(matchingFrame, src, trg, key)
 					case key.isOneToMany:
-						patternBodyStub.addSearchOperation(new ExtendMultiNavigationStub(matchingFrame, src, trg, key))
+						operations += new ExtendMultiNavigationStub(matchingFrame, src, trg, key)
 				}
 			}
 		}
+		return operations
 	}
 
-	def dispatch void createExtend(ExportedParameter constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createExtend(ExportedParameter constraint) {
 		// nop
+		#[]
 	}
 
-	def dispatch void createExtend(PConstraint constraint, Map<PVariable, Integer> variableMapping) {
+	def dispatch createExtend(PConstraint constraint) {
 		println("Constraint type not yet implemented: " + constraint)
+		#[]
 	}
 
 	private def allBound(PConstraint pConstraint) {

plugins/hu.bme.mit.incquery.localsearch.cpp/src/hu/bme/mit/incquery/localsearch/cpp/generator/planner/PlanCompiler.xtend

@@ -1,33 +1,38 @@
 package hu.bme.mit.incquery.localsearch.cpp.generator.planner
 
+import com.google.common.collect.ImmutableSet
+import com.google.common.collect.Iterables
 import hu.bme.mit.incquery.localsearch.cpp.generator.model.PatternStub
 import java.util.List
 import org.apache.log4j.Logger
 import org.eclipse.viatra.query.runtime.emf.EMFQueryMetaContext
 import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PDisjunction
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import org.eclipse.viatra.query.runtime.matchers.psystem.rewriters.DefaultFlattenCallPredicate
 import org.eclipse.viatra.query.runtime.matchers.psystem.rewriters.PBodyNormalizer
 import org.eclipse.viatra.query.runtime.matchers.psystem.rewriters.PQueryFlattener
-import hu.bme.mit.incquery.localsearch.cpp.generator.model.QueryStub
-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter
 
 class PlanCompiler {
 
+	val PQueryFlattener flattener
+	val PBodyNormalizer normalizer	
 
 	extension val CPPLocalSearchRuntimeBasedStrategy strategy
 	extension val POperationCompiler compiler
 
-	
 	new () {
+		this.flattener = new PQueryFlattener(new DefaultFlattenCallPredicate)
+		this.normalizer = new PBodyNormalizer(null, false)
+		
 		this.strategy = new CPPLocalSearchRuntimeBasedStrategy(false)
 		this.compiler = new POperationCompiler
 	}
 
-	def compilePlan(PQuery pQuery, QueryStub queryStub) {
+	def compilePlan(PQuery pQuery) {
 		val bindings = pQuery.allAnnotations.filter[name == "Bind"]
-		bindings.forEach[ binding |
+		val boundPatternStubs = bindings.map[ binding |
 			val boundParameters = binding.getAllValues("parameters").map [
 				switch (it) {
 					ParameterReference: #[it]
@@ -37,33 +42,36 @@ class PlanCompiler {
 				pQuery.parameters.get(pQuery.getPositionOfParameter(it.name))
 			].toSet
 
-			val patternStub = queryStub.addPattern(pQuery, boundParameters)
-			pQuery.compile(patternStub, boundParameters, false)
+			val bodies = pQuery.compile(boundParameters, false)
+			return new PatternStub(pQuery, bodies, boundParameters)
 		]
 
-		val patternStub = queryStub.addPattern(pQuery)
-		pQuery.compile(patternStub, #{}, true)
+		val bodies = pQuery.compile(#{}, true)
+		val unboundPatternStub = new PatternStub(pQuery, bodies)
+		// copy to prevent lazy evaluation
+		return ImmutableSet::copyOf(Iterables::concat(#[unboundPatternStub], boundPatternStubs))
 	}
 
-	def compile(PQuery pQuery, PatternStub patternStub, Iterable<PParameter> boundParameters, boolean checkSanity) {
-		val flattener = new PQueryFlattener(new DefaultFlattenCallPredicate)
-		val normalizer = new PBodyNormalizer(null, false)
+	def compile(PQuery pQuery, Iterable<PParameter> boundParameters, boolean checkSanity) {
 
 		val flatDisjunction = flattener.rewrite(pQuery.disjunctBodies)
 		val normalizedDisjunction = normalizer.rewrite(flatDisjunction)
 
 		if (checkSanity && !normalizedDisjunction.sensibleWithoutBinding) 
-			return
+			return #{}
 
 		val normalizedBodies = normalizedDisjunction.bodies
 
-		normalizedBodies.forEach[pBody |
-			val boundPVariables = boundParameters.map[pBody.getVariableByNameChecked(name)].toSet
+		val patternBodyStubs = normalizedBodies.map[pBody |
+			val boundPVariables = boundParameters.map[pBody.getVariableByNameChecked(name)]
+												 .toSet
 
-			val patternBodyStub = patternStub.addPatternBody(pBody)
 			pBody.plan(Logger::getLogger(PlanCompiler), boundPVariables, EMFQueryMetaContext.INSTANCE, null, #{})
-				 .compile(pBody, boundPVariables, patternBodyStub)
-		]
+				 .compile(pBody, boundPVariables)
+				 
+		].toSet
+		
+		return patternBodyStubs
 	}
 
 	/**

plugins/hu.bme.mit.incquery.localsearch.cpp/src/hu/bme/mit/incquery/localsearch/cpp/generator/planner/util/CompilerHelper.xtend

@@ -1,10 +1,10 @@
 package hu.bme.mit.incquery.localsearch.cpp.generator.planner.util
 
-import com.google.common.base.Objects
 import com.google.common.collect.Iterables
 import com.google.common.collect.Lists
 import com.google.common.collect.Maps
 import com.google.common.collect.Sets
+import hu.bme.mit.incquery.localsearch.cpp.generator.model.TypeInfo
 import java.util.List
 import java.util.Map
 import java.util.Set
@@ -22,6 +22,7 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint
 
+// TODO: help... please...
 class CompilerHelper {
 
 	static def Map<PVariable, Integer> createVariableMapping(SubPlan plan) {
@@ -89,17 +90,17 @@ class CompilerHelper {
 		return variableBindings
 	}
 
-	static def Map<PVariable, TypeMap> createTypeMapping(SubPlan plan) {
-		val Map<PVariable, TypeMap> typeMapping = Maps::newHashMap()
+	static def Map<PVariable, TypeInfo> createTypeMapping(SubPlan plan) {
+		val Map<PVariable, TypeInfo> typeMapping = Maps::newHashMap()
 		var Set<PVariable> allVarialbes = plan.getAllEnforcedConstraints().map[getAffectedVariables].flatten.toSet
 		allVarialbes.forEach[pVar |
 			var EClass leastStrictType = getLeastStrictType(pVar)
 			if (leastStrictType !== null) {
-				typeMapping.put(pVar, new TypeMap(leastStrictType, getStrictestType(pVar)))
+				typeMapping.put(pVar, new TypeInfo(leastStrictType, getStrictestType(pVar)))
 			} else {
 				var EDataType primitiveType = getPrimitiveType(pVar)
 				if (primitiveType !== null) {
-					typeMapping.put(pVar, new TypeMap(primitiveType, primitiveType))
+					typeMapping.put(pVar, new TypeInfo(primitiveType, primitiveType))
 				}
 			}
 		]
@@ -202,29 +203,5 @@ class CompilerHelper {
 		}
 		operationsList.add(plan.getOperation())
 		return Lists::reverse(operationsList)
-	}
-
-	static class TypeMap {
-		final EClassifier looseType
-		final EClassifier strictType
-
-		def EClassifier getLooseType() {
-			return looseType
-		}
-
-		def EClassifier getStrictType() {
-			return strictType
-		}
-
-		new(EClassifier looseType, EClassifier strictType) {
-			super()
-			this.looseType = looseType
-			this.strictType = strictType
-		}
-
-		override String toString() {
-			return Objects::toStringHelper(this).add("looseType", looseType.getName()).add("strictType",
-				strictType.getName()).toString()
-		}
-	}
+	} 
 }