1 files changed, 99 insertions, 80 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
index 677170b8..edf92343 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -1,7 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

 import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion

-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference

@@ -17,17 +16,22 @@ import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Transform
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraints

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import java.util.Collection

 import java.util.HashMap

 import java.util.Map

 import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EReference

+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery

 import org.eclipse.xtend.lib.annotations.Accessors

+import org.eclipse.xtend.lib.annotations.Data

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import org.eclipse.xtend.lib.annotations.Data

-import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

 

 @Data class PatternGeneratorResult {

         CharSequence patternText

@@ -35,22 +39,32 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
         HashMap<PConstraint,String> constraint2CurrentPreconditionName

 }

 

+interface UnitPropagationPatternGenerator {

+        def Map<Relation, String> getMustPatterns()

+        

+        def Map<Relation, String> getMustNotPatterns()

+        

+        def StringConcatenationClient getAdditionalPatterns(PatternGenerator generator, Map<String, PQuery> fqn2PQuery)

+}

+

 class PatternGenerator {

-        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer //= new TypeIndexer(this)

-        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(this)

-        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(this)

+        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer // = new TypeIndexer(this)

+        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(

+                this)

+        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(

+                this)

         @Accessors(PUBLIC_GETTER) val ContainmentIndexer containmentIndexer = new ContainmentIndexer(this)

         @Accessors(PUBLIC_GETTER) val InvalidIndexer invalidIndexer = new InvalidIndexer(this)

-        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer = new UnfinishedIndexer(this)

+        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer

         @Accessors(PUBLIC_GETTER) val TypeRefinementGenerator typeRefinementGenerator //= new RefinementGenerator(this)

         @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(this)

         @Accessors(PUBLIC_GETTER) val UnitPropagationPreconditionGenerator unitPropagationPreconditionGenerator = new UnitPropagationPreconditionGenerator(this)

         

-        public new(TypeInferenceMethod typeInferenceMethod) {

+        new(TypeInferenceMethod typeInferenceMethod, ScopePropagatorStrategy scopePropagatorStrategy) {

                 if(typeInferenceMethod == TypeInferenceMethod.Generic) {

                         this.typeIndexer = new GenericTypeIndexer(this)

                         this.typeRefinementGenerator = new GenericTypeRefinementGenerator(this)

-                } else if(typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {

+                } else if (typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {

                         this.typeIndexer = new TypeIndexerWithPreliminaryTypeAnalysis(this)

                         this.typeRefinementGenerator = new TypeRefinementWithPreliminaryTypeAnalysis(this)

                 } else {

@@ -58,110 +72,102 @@ class PatternGenerator {
                         this.typeRefinementGenerator = null

                         throw new IllegalArgumentException('''Unknown type indexing technique : «typeInferenceMethod.name»''')

                 }

+                this.unfinishedIndexer = new UnfinishedIndexer(this, scopePropagatorStrategy.requiresUpperBoundIndexing)

         }

-        

-        public def requiresTypeAnalysis() {

+

+        def requiresTypeAnalysis() {

                 typeIndexer.requiresTypeAnalysis || typeRefinementGenerator.requiresTypeAnalysis

         }

-        

-        public dispatch def referRelation(

-                RelationDeclaration referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

-                return this.relationDeclarationIndexer.referRelation(referred,sourceVariable,targetVariable,modality)

+

+        dispatch def CharSequence referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,

+                Modality modality, Map<String, PQuery> fqn2PQuery) {

+                return this.relationDeclarationIndexer.referRelation(referred, sourceVariable, targetVariable, modality)

         }

-        public dispatch def referRelation(

-                RelationDefinition referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

-                val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)

-                return this.relationDefinitionIndexer.referPattern(pattern,#[sourceVariable,targetVariable],modality,true,false)

+

+        dispatch def CharSequence referRelation(RelationDefinition referred, String sourceVariable, String targetVariable,

+                Modality modality, Map<String, PQuery> fqn2PQuery) {

+                val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(

+                        fqn2PQuery)

+                return this.relationDefinitionIndexer.referPattern(pattern, #[sourceVariable, targetVariable], modality, true,

+                        false)

         }

-        

-        def public referRelationByName(EReference reference,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')

-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''

+

+        def referRelationByName(EReference reference, String sourceVariable, String targetVariable, Modality modality) {

+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

         }

-        

-        def public CharSequence referAttributeByName(EAttribute attribute,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')

-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''

+

+        def CharSequence referAttributeByName(EAttribute attribute, String sourceVariable, String targetVariable,

+                Modality modality) {

+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

         }

-        

-        public def canonizeName(String name) {

+

+        def canonizeName(String name) {

                 name.split(' ').join('_')

         }

-        

-        public def lowerMultiplicities(LogicProblem problem) {

-                problem.assertions.map[annotations].flatten.filter(LowerMultiplicityAssertion).filter[!it.relation.isDerived]

-        }

-        public def wfQueries(LogicProblem problem) {

-                problem.assertions.map[it.annotations]

-                        .flatten

-                        .filter(TransformedViatraWellformednessConstraint)

-                        .map[it.query]

+

+        def wfQueries(LogicProblem problem) {

+                problem.assertions.map[it.annotations].flatten.filter(TransformedViatraWellformednessConstraint).map[it.query]

         }

-        public def getContainments(LogicProblem p) {

+

+        def getContainments(LogicProblem p) {

                 return p.containmentHierarchies.head.containmentRelations

         }

-        public def getInverseRelations(LogicProblem p) {

+

+        def getInverseRelations(LogicProblem p) {

                 val inverseRelations = new HashMap

-                p.annotations.filter(InverseRelationAssertion).forEach[

-                        inverseRelations.put(it.inverseA,it.inverseB)

-                        inverseRelations.put(it.inverseB,it.inverseA)

+                p.annotations.filter(InverseRelationAssertion).forEach [

+                        inverseRelations.put(it.inverseA, it.inverseB)

+                        inverseRelations.put(it.inverseB, it.inverseA)

                 ]

                 return inverseRelations

         }

-        public def isRepresentative(Relation relation, Relation inverse) {

-                if(inverse == null) {

+

+        def isRepresentative(Relation relation, Relation inverse) {

+                if (relation === null) {

+                        return false

+                } else if (inverse === null) {

                         return true

                 } else {

-                        relation.name.compareTo(inverse.name)<1

+                        relation.name.compareTo(inverse.name) < 1

                 }

         }

-        

-        public def isDerived(Relation relation) {

+

+        def isDerived(Relation relation) {

                 relation.annotations.exists[it instanceof DefinedByDerivedFeature]

         }

-        public def getDerivedDefinition(RelationDeclaration relation) {

+

+        def getDerivedDefinition(RelationDeclaration relation) {

                 relation.annotations.filter(DefinedByDerivedFeature).head.query

         }

-        

+

         private def allTypeReferences(LogicProblem problem) {

                 problem.eAllContents.filter(TypeReference).toIterable

         }

+

         protected def hasBoolean(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof BoolTypeReference]

         }

+

         protected def hasInteger(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof IntTypeReference]

         }

+

         protected def hasReal(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof RealTypeReference]

         }

+

         protected def hasString(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof StringTypeReference]

         }

-        

-        public def PatternGeneratorResult transformBaseProperties(

+

+        def transformBaseProperties(

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

-                Map<String,PQuery> fqn2PQuery,

-                TypeAnalysisResult typeAnalysisResult

+                Map<String, PQuery> fqn2PQuery,

+                TypeAnalysisResult typeAnalysisResult,

+                RelationConstraints constraints,

+                Collection<LinearTypeConstraintHint> hints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators

         ) {

                 val first = 

                  '''

@@ -199,7 +205,7 @@ class PatternGenerator {
                         

                         private pattern elementCloseWorld(element:DefinedElement) {

                                 PartialInterpretation.openWorldElements(i,element);

-                            PartialInterpretation.maxNewElements(i,0);

+                                PartialInterpretation.maxNewElements(i,0);

                         } or {

                                 Scope.targetTypeInterpretation(scope,interpretation);

                                 PartialTypeInterpratation.elements(interpretation,element);

@@ -288,7 +294,9 @@ class PatternGenerator {
                         //////////

                         // 1.1.1 Required Patterns by TypeIndexer

                         //////////

+

                         «typeIndexer.requiredQueries»

+                        

                         //////////

                         // 1.1.2 primitive Type Indexers

                         //////////

@@ -306,6 +314,7 @@ class PatternGenerator {
                         // > StringElement.value(variableName,value)

                         // Whether a value is set is defined by:

                         // > PrimitiveElement.valueSet(variableName,isFilled);

+                        

                         //////////

                         // 1.1.3 domain-specific Type Indexers

                         //////////

@@ -314,7 +323,7 @@ class PatternGenerator {
                         //////////

                         // 1.2 Relation Declaration Indexers

                         //////////

-                        «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),fqn2PQuery)»

+                        «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),unitPropagationPatternGenerators,fqn2PQuery)»

                         

                         //////////

                         // 1.3 Relation Definition Indexers

@@ -338,7 +347,7 @@ class PatternGenerator {
                         //////////

                         // 3.1 Unfinishedness Measured by Multiplicity

                         //////////

-                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(problem,fqn2PQuery)»

+                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(constraints.multiplicityConstraints,fqn2PQuery)»

                         

                         //////////

                         // 3.2 Unfinishedness Measured by WF Queries

@@ -360,14 +369,24 @@ class PatternGenerator {
                         //////////

                         // 4.3 Relation refinement

                         //////////

-                        «relationRefinementGenerator.generateRefineReference(problem)»

+                        «relationRefinementGenerator.generateRefineReference(problem, unitPropagationPatternGenerators)»

+                        

+                        //////////

+                        // 5 Hints

+                        //////////

+                        «FOR hint : hints»

+                                «hint.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

+                        «FOR generator : unitPropagationPatternGenerators»

+                                «generator.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

                         

                         //////////

-                        // 5 Unit Propagations

+                        // 6 Unit Propagations

                         //////////

                         '''

-                        val up = unitPropagationPreconditionGenerator.generateUnitPropagationRules(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)

-                        val second = up.definitions

-                        return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)

+                val up = unitPropagationPreconditionGenerator.generateUnitPropagationRules(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)

+                val second = up.definitions

+                return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)

         }

 }