diff options
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf')
22 files changed, 2132 insertions, 0 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java new file mode 100644 index 00000000..d2132cea --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java | |||
@@ -0,0 +1,22 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra; | ||
2 | |||
3 | public enum Modality { | ||
4 | MUST, MAY, CURRENT; | ||
5 | public boolean isMust() { | ||
6 | return this == MUST; | ||
7 | } | ||
8 | public boolean isMay() { | ||
9 | return this == MAY; | ||
10 | } | ||
11 | public boolean isCurrent() { | ||
12 | return this == CURRENT; | ||
13 | } | ||
14 | public boolean isMustOrCurrent() { | ||
15 | return isMust() || isCurrent(); | ||
16 | } | ||
17 | public Modality getDual() { | ||
18 | if(this.isCurrent()) return CURRENT; | ||
19 | else if(this.isMust())return MAY; | ||
20 | else return MUST; | ||
21 | } | ||
22 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend new file mode 100644 index 00000000..1653226d --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend | |||
@@ -0,0 +1,78 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternProvider | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.GoalConstraintProvider | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.RefinementRuleProvider | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
10 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | ||
11 | import java.util.Collection | ||
12 | import java.util.LinkedHashMap | ||
13 | import java.util.List | ||
14 | import org.eclipse.viatra.query.runtime.api.GenericPatternMatch | ||
15 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
16 | import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher | ||
17 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
18 | import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule | ||
19 | import org.eclipse.xtend.lib.annotations.Data | ||
20 | import org.eclipse.viatra.query.runtime.api.IPatternMatch | ||
21 | |||
22 | class ModelGenerationStatistics { | ||
23 | public var long transformationExecutionTime = 0 | ||
24 | synchronized def addExecutionTime(long amount) { | ||
25 | transformationExecutionTime+=amount | ||
26 | } | ||
27 | public var long PreliminaryTypeAnalisisTime = 0 | ||
28 | } | ||
29 | @Data class ModelGenerationMethod { | ||
30 | ModelGenerationStatistics statistics | ||
31 | |||
32 | Collection<? extends BatchTransformationRule<?,?>> objectRefinementRules | ||
33 | Collection<? extends BatchTransformationRule<?,?>> relationRefinementRules | ||
34 | |||
35 | List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities | ||
36 | Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF | ||
37 | |||
38 | Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWF | ||
39 | } | ||
40 | enum TypeInferenceMethod { | ||
41 | Generic, PreliminaryAnalysis | ||
42 | } | ||
43 | |||
44 | class ModelGenerationMethodProvider { | ||
45 | private val PatternProvider patternProvider = new PatternProvider | ||
46 | private val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider | ||
47 | private val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider | ||
48 | |||
49 | public def ModelGenerationMethod createModelGenerationMethod( | ||
50 | LogicProblem logicProblem, | ||
51 | PartialInterpretation emptySolution, | ||
52 | Iterable<PQuery> existingQueries, | ||
53 | ReasonerWorkspace workspace, | ||
54 | boolean nameNewElements, | ||
55 | TypeInferenceMethod typeInferenceMethod | ||
56 | ) { | ||
57 | val statistics = new ModelGenerationStatistics | ||
58 | val queries = patternProvider.generateQueries(logicProblem,emptySolution,statistics,existingQueries,workspace,typeInferenceMethod) | ||
59 | |||
60 | val //LinkedHashMap<Pair<Relation, ? extends Type>, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> | ||
61 | objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(queries,nameNewElements,statistics) | ||
62 | val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries,statistics) | ||
63 | |||
64 | val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(queries) | ||
65 | val unfinishedWF = queries.getUnfinishedWFQueries.values | ||
66 | |||
67 | val invalidWF = queries.getInvalidWFQueries.values | ||
68 | |||
69 | return new ModelGenerationMethod( | ||
70 | statistics, | ||
71 | objectRefinementRules.values, | ||
72 | relationRefinementRules.values, | ||
73 | unfinishedMultiplicities, | ||
74 | unfinishedWF, | ||
75 | invalidWF | ||
76 | ) | ||
77 | } | ||
78 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend new file mode 100644 index 00000000..e05160d0 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend | |||
@@ -0,0 +1,46 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra | ||
2 | |||
3 | import org.eclipse.emf.common.notify.Notifier | ||
4 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
5 | import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine | ||
6 | import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher | ||
7 | import org.eclipse.viatra.query.runtime.emf.EMFScope | ||
8 | |||
9 | class MultiplicityGoalConstraintCalculator { | ||
10 | val String targetRelationName; | ||
11 | val IQuerySpecification<?> querySpecification; | ||
12 | var ViatraQueryMatcher<?> matcher; | ||
13 | |||
14 | public new(String targetRelationName, IQuerySpecification<?> querySpecification) { | ||
15 | this.targetRelationName = targetRelationName | ||
16 | this.querySpecification = querySpecification | ||
17 | this.matcher = null | ||
18 | } | ||
19 | |||
20 | public new(MultiplicityGoalConstraintCalculator other) { | ||
21 | this.targetRelationName = other.targetRelationName | ||
22 | this.querySpecification = other.querySpecification | ||
23 | this.matcher = null | ||
24 | } | ||
25 | |||
26 | def public getName() { | ||
27 | targetRelationName | ||
28 | } | ||
29 | |||
30 | def public init(Notifier notifier) { | ||
31 | val engine = ViatraQueryEngine.on(new EMFScope(notifier)) | ||
32 | matcher = querySpecification.getMatcher(engine) | ||
33 | } | ||
34 | |||
35 | def public calculateValue() { | ||
36 | var res = 0 | ||
37 | val allMatches = this.matcher.allMatches | ||
38 | for(match : allMatches) { | ||
39 | //println(targetRelationName+ " missing multiplicity: "+match.get(3)) | ||
40 | val missingMultiplicity = match.get(4) as Integer | ||
41 | res += missingMultiplicity | ||
42 | } | ||
43 | //println(targetRelationName+ " all missing multiplicities: "+res) | ||
44 | return res | ||
45 | } | ||
46 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeAnalysis.xtend new file mode 100644 index 00000000..395aba85 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeAnalysis.xtend | |||
@@ -0,0 +1,92 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra | ||
2 | |||
3 | import org.eclipse.xtend.lib.annotations.Data | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import java.util.List | ||
6 | import java.util.Map | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
9 | import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine | ||
10 | import org.eclipse.viatra.query.runtime.emf.EMFScope | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.NewElementTypeConstructorMatcher | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.NewElementTypeRefinementTargetMatcher | ||
13 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.NewElementTypeRefinementNegativeConstraintMatcher | ||
14 | import java.util.ArrayList | ||
15 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.DontHaveDefinedSupertypeMatcher | ||
16 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration | ||
17 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
18 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.NewElementMayTypeNegativeConstraintMatcher | ||
19 | |||
20 | @Data class TypeRefinementPrecondition { | ||
21 | Type targetType | ||
22 | List<? extends Type> inhibitorTypes | ||
23 | } | ||
24 | |||
25 | /** | ||
26 | * Collection of all possible element creation and type refinement rules for defined and undefined elements. | ||
27 | */ | ||
28 | @Data class TypeAnalysisResult { | ||
29 | ///////////////// | ||
30 | // New elements | ||
31 | ///////////////// | ||
32 | /** | ||
33 | * New elements can be created using with the following types. | ||
34 | */ | ||
35 | List<? extends Type> possibleNewDynamicTypes | ||
36 | /** | ||
37 | * <b>(A,B)</b> in <b>possibleNewTypeRefinements</b>: a new element <b>x</b> can be refined to A <=> <b>x</b> has all types listed in B. | ||
38 | */ | ||
39 | List<TypeRefinementPrecondition> possibleNewTypeRefinements | ||
40 | /** | ||
41 | * A new element may have type A if it already has types | ||
42 | */ | ||
43 | Map<? extends Type,TypeRefinementPrecondition> mayNewTypePreconditions | ||
44 | |||
45 | ///////////////// | ||
46 | // Old elements | ||
47 | ///////////////// | ||
48 | |||
49 | /** | ||
50 | * <b>(A,B)</b> in <b>possibleNewTypeRefinements</b>: a new element <b>x</b> can be refined to A <=> <b>x</b> has all types listed in B. | ||
51 | */ | ||
52 | Map<DefinedElement,TypeRefinementPrecondition> possibleOldTypeRefinements | ||
53 | /** | ||
54 | * A new element may have type A if it already has types | ||
55 | */ | ||
56 | Map<? extends Type,Map<DefinedElement,TypeRefinementPrecondition>> mayOldTypePreconditions | ||
57 | } | ||
58 | |||
59 | class TypeAnalysis { | ||
60 | |||
61 | def TypeAnalysisResult performTypeAnalysis(LogicProblem problem, PartialInterpretation interpretation) { | ||
62 | val viatraEngine = ViatraQueryEngine.on(new EMFScope(problem)) | ||
63 | val negativeMatcher = NewElementTypeRefinementNegativeConstraintMatcher.on(viatraEngine) | ||
64 | |||
65 | val possibleNewDynamicTypes = NewElementTypeConstructorMatcher.on(viatraEngine).allValuesOftype | ||
66 | |||
67 | val possibleNewTypeRefinementTargets = NewElementTypeRefinementTargetMatcher.on(viatraEngine).allValuesOfrefined | ||
68 | val possibleNewTypeRefinements = new ArrayList | ||
69 | for(possibleNewTypeRefinementTarget : possibleNewTypeRefinementTargets) { | ||
70 | val inhibitorTypes = negativeMatcher.getAllValuesOfinhibitor(possibleNewTypeRefinementTarget) | ||
71 | possibleNewTypeRefinements += new TypeRefinementPrecondition( | ||
72 | possibleNewTypeRefinementTarget, | ||
73 | inhibitorTypes.toList) | ||
74 | } | ||
75 | |||
76 | val possibleTypes = DontHaveDefinedSupertypeMatcher.on(viatraEngine).allValuesOftype | ||
77 | val newElementMayTypeMatcher = NewElementMayTypeNegativeConstraintMatcher.on(viatraEngine) | ||
78 | |||
79 | val mayNewTypePreconditions = possibleTypes.toInvertedMap[type | | ||
80 | val inhibitorTypes = newElementMayTypeMatcher.getAllValuesOfinhibitor(type as TypeDeclaration) | ||
81 | return new TypeRefinementPrecondition(type,inhibitorTypes.toList) | ||
82 | ] | ||
83 | |||
84 | return new TypeAnalysisResult( | ||
85 | possibleNewDynamicTypes.toList, | ||
86 | possibleNewTypeRefinements, | ||
87 | mayNewTypePreconditions, | ||
88 | emptyMap, | ||
89 | emptyMap | ||
90 | ) | ||
91 | } | ||
92 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend new file mode 100644 index 00000000..02e58c9b --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend | |||
@@ -0,0 +1,41 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
4 | import java.util.Collection | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
6 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
7 | import java.util.Map | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
9 | |||
10 | class ContainmentIndexer { | ||
11 | val PatternGenerator base; | ||
12 | |||
13 | new(PatternGenerator base) { | ||
14 | this.base = base | ||
15 | } | ||
16 | |||
17 | def isContainmentRelation(Relation relation, LogicProblem problem) { | ||
18 | problem.containmentHierarchies.exists[it.containmentRelations.contains(relation)] | ||
19 | } | ||
20 | |||
21 | def transformContainment(LogicProblem problem, Collection<Relation> relations,Map<String,PQuery> fqn2PQuery) | ||
22 | ''' | ||
23 | private pattern mustContains2(source: DefinedElement, target: DefinedElement) { | ||
24 | find mustContains4(_,_,source,target); | ||
25 | } | ||
26 | |||
27 | private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, | ||
28 | source: DefinedElement, target: DefinedElement) | ||
29 | «FOR reference : relations.filter[isContainmentRelation(problem)] SEPARATOR 'or\n'» | ||
30 | { «base.referRelation(reference,"source","target",Modality.MUST,fqn2PQuery)» } | ||
31 | «ENDFOR» | ||
32 | |||
33 | private pattern mustTransitiveContains(source,target) { | ||
34 | find mustContains2+(source,target); | ||
35 | } | ||
36 | ''' | ||
37 | def referMustContaint(String source, String target) | ||
38 | '''find mustContains4(problem,interpretation,«source»,«target»);''' | ||
39 | def referTransitiveMustContains(String source, String target) | ||
40 | '''find mustTransitiveContains(source,target);''' | ||
41 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend new file mode 100644 index 00000000..fbbd9fb5 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend | |||
@@ -0,0 +1,194 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import org.eclipse.emf.ecore.EClass | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
9 | |||
10 | class GenericTypeIndexer implements TypeIndexer { | ||
11 | val PatternGenerator base; | ||
12 | |||
13 | new(PatternGenerator base) { | ||
14 | this.base = base | ||
15 | } | ||
16 | override requiresTypeAnalysis() { false } | ||
17 | |||
18 | public override getRequiredQueries() ''' | ||
19 | private pattern newELement(interpretation: PartialInterpretation, element: DefinedElement) { | ||
20 | PartialInterpretation.newElements(interpretation,element); | ||
21 | } | ||
22 | |||
23 | private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialTypeInterpratation) { | ||
24 | find interpretation(problem,interpetation); | ||
25 | LogicProblem.types(problem,type); | ||
26 | PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation); | ||
27 | PartialTypeInterpratation.interpretationOf(typeInterpretation,type); | ||
28 | } | ||
29 | |||
30 | private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) { | ||
31 | find interpretation(problem,interpetation); | ||
32 | find mustExist(problem,interpetation,element); | ||
33 | LogicProblem.types(problem,type); | ||
34 | TypeDefinition.elements(type,element); | ||
35 | } or { | ||
36 | find mustExist(problem,interpetation,element); | ||
37 | find typeInterpretation(problem,interpetation,type,typeInterpretation); | ||
38 | PartialTypeInterpratation.elements(typeInterpretation,element); | ||
39 | } | ||
40 | |||
41 | /** | ||
42 | * Direct supertypes of a type. | ||
43 | */ | ||
44 | private pattern supertypeDirect(subtype : Type, supertype : Type) { | ||
45 | Type.supertypes(subtype, supertype); | ||
46 | } | ||
47 | |||
48 | /** | ||
49 | * All supertypes of a type. | ||
50 | */ | ||
51 | private pattern supertypeStar(subtype: Type, supertype: Type) { | ||
52 | subtype == supertype; | ||
53 | } or { | ||
54 | find supertypeDirect+(subtype,supertype); | ||
55 | } | ||
56 | |||
57 | /// Complex type reasoning patterns /// | ||
58 | // | ||
59 | // In a valid type system, for each element e there is exactly one type T where | ||
60 | // 1: T(e) - but we dont know this for type declaration | ||
61 | // 2: For the dynamic type D and another type T, where D(e) && D-->T, T(e) is true. | ||
62 | // 2e: A type hierarchy is invalid, if there is a supertype T for a dynamic type D which does no contains e: | ||
63 | // D(e) && D-->T && !T(e) | ||
64 | // 3: There is no T' that T'->T and T'(e) | ||
65 | // 3e: A type hierarcy is invalid, if there is a type T for a dynamic type D, which contains e, but not subtype of T: | ||
66 | // D(e) && ![T--->D] && T(e) | ||
67 | // 4: T is not abstract | ||
68 | // Such type T is called Dynamic type of e, while other types are called static types. | ||
69 | // | ||
70 | // The following patterns checks the possible dynamic types for an element | ||
71 | |||
72 | private pattern wellformedType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement) { | ||
73 | // 1: T(e) | ||
74 | find directInstanceOf(problem,interpretation,element,dynamic); | ||
75 | // 2e is not true: D(e) && D-->T && !T(e) | ||
76 | neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic); | ||
77 | // 3e is not true: D(e) && ![T--->D] && T(e) | ||
78 | neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic); | ||
79 | // 4: T is not abstract | ||
80 | Type.isAbstract(dynamic,false); | ||
81 | } | ||
82 | |||
83 | private pattern possibleDynamicType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement) | ||
84 | // case 1: element is defined at least once | ||
85 | { | ||
86 | LogicProblem.types(problem,dynamic); | ||
87 | // select a random definition 'randomType' | ||
88 | find directInstanceOf(problem,interpretation,element,randomType); | ||
89 | // dynamic is a subtype of 'randomType' | ||
90 | find supertypeStar(dynamic,randomType); | ||
91 | // 2e is not true: D(e) && D-->T && !T(e) | ||
92 | neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic); | ||
93 | // 3e is not true: D(e) && ![T--->D] && T(e) | ||
94 | neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic); | ||
95 | // 4: T is not abstract | ||
96 | Type.isAbstract(dynamic,false); | ||
97 | } or | ||
98 | // case 2: element is not defined anywhere | ||
99 | { | ||
100 | find mayExist(problem,interpretation,element); | ||
101 | // there is no definition | ||
102 | neg find directInstanceOf(problem,interpretation,element,_); | ||
103 | // 2e is not true: D(e) && D-->T && !T(e) | ||
104 | // because non of the definition contains element, the type cannot have defined supertype | ||
105 | LogicProblem.types(problem,dynamic); | ||
106 | PartialInterpretation.problem(interpretation,problem); | ||
107 | neg find typeWithDefinedSupertype(dynamic); | ||
108 | // 3e is not true: D(e) && ![T--->D] && T(e) | ||
109 | // because there is no definition, dynamic covers all definition | ||
110 | // 4: T is not abstract | ||
111 | Type.isAbstract(dynamic,false); | ||
112 | } | ||
113 | |||
114 | /** | ||
115 | * supertype -------> element <------- otherSupertype | ||
116 | * A A | ||
117 | * | | | ||
118 | * wrongDynamic -----------------------------X | ||
119 | */ | ||
120 | private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) { | ||
121 | find directInstanceOf(problem,interpretation,element,supertype); | ||
122 | find directInstanceOf(problem,interpretation,element,otherSupertype); | ||
123 | find supertypeStar(wrongDynamic,supertype); | ||
124 | neg find supertypeStar(wrongDynamic,otherSupertype); | ||
125 | } | ||
126 | |||
127 | /** | ||
128 | * supertype -------> element <---X--- otherSupertype | ||
129 | * A A | ||
130 | * | | | ||
131 | * wrongDynamic -----------------------------+ | ||
132 | */ | ||
133 | private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) { | ||
134 | find directInstanceOf(problem,interpretation,element,supertype); | ||
135 | neg find elementInTypeDefinition(element,otherSupertype); | ||
136 | TypeDefinition(otherSupertype); | ||
137 | find supertypeStar(wrongDynamic, supertype); | ||
138 | find supertypeStar(wrongDynamic, otherSupertype); | ||
139 | } | ||
140 | |||
141 | private pattern elementInTypeDefinition(element:DefinedElement, definition:TypeDefinition) { | ||
142 | TypeDefinition.elements(definition,element); | ||
143 | } | ||
144 | |||
145 | private pattern typeWithDefinedSupertype(type:Type) { | ||
146 | find supertypeStar(type,definedSupertype); | ||
147 | TypeDefinition(definedSupertype); | ||
148 | } | ||
149 | ''' | ||
150 | |||
151 | public override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult) { | ||
152 | ''' | ||
153 | «FOR type:problem.types» | ||
154 | «problem.generateMustInstenceOf(type)» | ||
155 | «problem.generateMayInstanceOf(type)» | ||
156 | «ENDFOR» | ||
157 | ''' | ||
158 | } | ||
159 | |||
160 | private def patternName(Type type, Modality modality) | ||
161 | '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»''' | ||
162 | |||
163 | private def generateMustInstenceOf(LogicProblem problem, Type type) { | ||
164 | ''' | ||
165 | /** | ||
166 | * An element must be an instance of type "«type.name»". | ||
167 | */ | ||
168 | private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { | ||
169 | Type.name(type,"«type.name»"); | ||
170 | find directInstanceOf(problem,interpretation,element,type); | ||
171 | } | ||
172 | ''' | ||
173 | } | ||
174 | |||
175 | private def generateMayInstanceOf(LogicProblem problem, Type type) { | ||
176 | ''' | ||
177 | /** | ||
178 | * An element may be an instance of type "«type.name»". | ||
179 | */ | ||
180 | private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { | ||
181 | Type.name(type,"«type.name»"); | ||
182 | find possibleDynamicType(problem,interpretation,dynamic,element); | ||
183 | find supertypeStar(dynamic,type); | ||
184 | } | ||
185 | ''' | ||
186 | } | ||
187 | |||
188 | public override referInstanceOf(Type type, Modality modality, String variableName) { | ||
189 | '''find «patternName(type,modality)»(problem,interpretation,«variableName»);''' | ||
190 | } | ||
191 | public override referInstanceOf(EClass type, Modality modality, String variableName) { | ||
192 | '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''class «type.name»''')»(problem,interpretation,«variableName»);''' | ||
193 | } | ||
194 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend new file mode 100644 index 00000000..4b7af959 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend | |||
@@ -0,0 +1,102 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
10 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
11 | import java.util.HashMap | ||
12 | |||
13 | class GenericTypeRefinementGenerator extends TypeRefinementGenerator { | ||
14 | public new(PatternGenerator base) { | ||
15 | super(base) | ||
16 | } | ||
17 | override requiresTypeAnalysis() { false } | ||
18 | |||
19 | override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
20 | val containment = p.containmentHierarchies.head | ||
21 | val newObjectTypes = p.types.filter(TypeDeclaration).filter[!isAbstract] | ||
22 | val inverseRelations = new HashMap | ||
23 | p.annotations.filter(InverseRelationAssertion).forEach[ | ||
24 | inverseRelations.put(it.inverseA,it.inverseB) | ||
25 | inverseRelations.put(it.inverseB,it.inverseA) | ||
26 | ] | ||
27 | return ''' | ||
28 | «FOR type:newObjectTypes» | ||
29 | «IF(containment.typesOrderedInHierarchy.contains(type))» | ||
30 | «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]» | ||
31 | «IF inverseRelations.containsKey(containmentRelation)» | ||
32 | pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»( | ||
33 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
34 | relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation ,typeInterpretation:PartialTypeInterpratation, | ||
35 | container:DefinedElement) | ||
36 | { | ||
37 | find interpretation(problem,interpretation); | ||
38 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
39 | PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»"); | ||
40 | PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); | ||
41 | PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»"); | ||
42 | PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); | ||
43 | PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»"); | ||
44 | «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")» | ||
45 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
46 | «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)» | ||
47 | find mustExist(problem, interpretation, container); | ||
48 | neg find mustExist(problem, interpretation, newObject); | ||
49 | } | ||
50 | «ELSE» | ||
51 | pattern «this.patternName(containmentRelation,null,type)»( | ||
52 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
53 | relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation, | ||
54 | container:DefinedElement) | ||
55 | { | ||
56 | find interpretation(problem,interpretation); | ||
57 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
58 | PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»"); | ||
59 | PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); | ||
60 | PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»"); | ||
61 | «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")» | ||
62 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
63 | «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)» | ||
64 | find mustExist(problem, interpretation, container); | ||
65 | neg find mustExist(problem, interpretation, newObject); | ||
66 | } | ||
67 | «ENDIF» | ||
68 | «ENDFOR» | ||
69 | «ELSE» | ||
70 | pattern createObject_«this.patternName(null,null,type)»( | ||
71 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
72 | typeInterpretation:PartialTypeInterpratation) | ||
73 | { | ||
74 | find interpretation(problem,interpretation); | ||
75 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
76 | PartialTypeInterpratation.interpretationOf.name(type,"«type.name»"); | ||
77 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
78 | find mayExist(problem, interpretation, newObject); | ||
79 | neg find mustExist(problem, interpretation, newObject); | ||
80 | } | ||
81 | «ENDIF» | ||
82 | «ENDFOR» | ||
83 | ''' | ||
84 | } | ||
85 | |||
86 | override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
87 | return ''' | ||
88 | «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]» | ||
89 | pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) { | ||
90 | find interpretation(problem,interpretation); | ||
91 | find mustExist(problem, interpretation, object); | ||
92 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")» | ||
93 | neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")» | ||
94 | } | ||
95 | «ENDFOR» | ||
96 | ''' | ||
97 | } | ||
98 | |||
99 | override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
100 | p.types.filter(TypeDeclaration).toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»'''] | ||
101 | } | ||
102 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend new file mode 100644 index 00000000..d9ede2a8 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend | |||
@@ -0,0 +1,53 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
4 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint | ||
5 | import java.util.Map | ||
6 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
7 | |||
8 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.lookup | ||
9 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition | ||
10 | import java.util.LinkedHashMap | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
12 | |||
13 | class InvalidIndexer { | ||
14 | val PatternGenerator patternGenerator | ||
15 | |||
16 | public new(PatternGenerator patternGenerator) { | ||
17 | this.patternGenerator = patternGenerator | ||
18 | } | ||
19 | |||
20 | public def getWFQueryName(RelationDefinition query) '''invalidWFQuery_«patternGenerator.canonizeName(query.name)»''' | ||
21 | |||
22 | public def generateInvalidatedByWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) { | ||
23 | val wfQueries = problem.assertions.map[it.annotations] | ||
24 | .flatten | ||
25 | .filter(TransformedViatraWellformednessConstraint) | ||
26 | .map[it.query] | ||
27 | ''' | ||
28 | «FOR wfQuery: wfQueries» | ||
29 | pattern invalidatedBy_«patternGenerator.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation, | ||
30 | «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR») | ||
31 | { | ||
32 | «patternGenerator.relationDefinitionIndexer.referPattern( | ||
33 | wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery), | ||
34 | wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''], | ||
35 | Modality.MUST, | ||
36 | true,false)» | ||
37 | } | ||
38 | «ENDFOR» | ||
39 | ''' | ||
40 | } | ||
41 | |||
42 | public def getInvalidateByWfQueryNames(LogicProblem problem) { | ||
43 | val wfQueries = problem.assertions.map[it.annotations] | ||
44 | .flatten | ||
45 | .filter(TransformedViatraWellformednessConstraint) | ||
46 | .map[it.query] | ||
47 | val map = new LinkedHashMap | ||
48 | for(wfQuery : wfQueries) { | ||
49 | map.put(wfQuery.target, '''invalidatedBy_«patternGenerator.canonizeName(wfQuery.target.name)»''') | ||
50 | } | ||
51 | return map | ||
52 | } | ||
53 | } | ||
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 new file mode 100644 index 00000000..291b605b --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend | |||
@@ -0,0 +1,244 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition | ||
5 | import java.util.Map | ||
6 | import org.eclipse.emf.ecore.EReference | ||
7 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
8 | import org.eclipse.xtend.lib.annotations.Accessors | ||
9 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery | ||
10 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
11 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
12 | import org.eclipse.emf.ecore.EAttribute | ||
13 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
14 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
15 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod | ||
16 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
17 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion | ||
18 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint | ||
19 | import java.util.HashMap | ||
20 | import java.util.HashSet | ||
21 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion | ||
22 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
23 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.DefinedByDerivedFeature | ||
24 | |||
25 | class PatternGenerator { | ||
26 | @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer //= new TypeIndexer(this) | ||
27 | @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(this) | ||
28 | @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(this) | ||
29 | @Accessors(PUBLIC_GETTER) val ContainmentIndexer containmentIndexer = new ContainmentIndexer(this) | ||
30 | @Accessors(PUBLIC_GETTER) val InvalidIndexer invalidIndexer = new InvalidIndexer(this) | ||
31 | @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer = new UnfinishedIndexer(this) | ||
32 | @Accessors(PUBLIC_GETTER) val TypeRefinementGenerator typeRefinementGenerator //= new RefinementGenerator(this) | ||
33 | @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(this) | ||
34 | |||
35 | public new(TypeInferenceMethod typeInferenceMethod) { | ||
36 | if(typeInferenceMethod == TypeInferenceMethod.Generic) { | ||
37 | this.typeIndexer = new GenericTypeIndexer(this) | ||
38 | this.typeRefinementGenerator = new GenericTypeRefinementGenerator(this) | ||
39 | } else if(typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) { | ||
40 | this.typeIndexer = new TypeIndexerWithPreliminaryTypeAnalysis(this) | ||
41 | this.typeRefinementGenerator = new TypeRefinementWithPreliminaryTypeAnalysis(this) | ||
42 | } else { | ||
43 | this.typeIndexer = null | ||
44 | this.typeRefinementGenerator = null | ||
45 | throw new IllegalArgumentException('''Unknown type indexing technique : «typeInferenceMethod.name»''') | ||
46 | } | ||
47 | } | ||
48 | |||
49 | public def requiresTypeAnalysis() { | ||
50 | typeIndexer.requiresTypeAnalysis || typeRefinementGenerator.requiresTypeAnalysis | ||
51 | } | ||
52 | |||
53 | public dispatch def referRelation( | ||
54 | RelationDeclaration referred, | ||
55 | String sourceVariable, | ||
56 | String targetVariable, | ||
57 | Modality modality, | ||
58 | Map<String,PQuery> fqn2PQuery) | ||
59 | { | ||
60 | return this.relationDeclarationIndexer.referRelation(referred,sourceVariable,targetVariable,modality) | ||
61 | } | ||
62 | public dispatch def referRelation( | ||
63 | RelationDefinition referred, | ||
64 | String sourceVariable, | ||
65 | String targetVariable, | ||
66 | Modality modality, | ||
67 | Map<String,PQuery> fqn2PQuery) | ||
68 | { | ||
69 | val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery) | ||
70 | return this.relationDefinitionIndexer.referPattern(pattern,#[sourceVariable,targetVariable],modality,true,false) | ||
71 | } | ||
72 | |||
73 | def public referRelationByName(EReference reference, | ||
74 | String sourceVariable, | ||
75 | String targetVariable, | ||
76 | Modality modality) | ||
77 | { | ||
78 | '''find «modality.name.toLowerCase»InRelation«canonizeName('''inreference «reference.name» «reference.EContainingClass.name»''') | ||
79 | »(problem,interpretation,«sourceVariable»,«targetVariable»);''' | ||
80 | } | ||
81 | |||
82 | def public CharSequence referAttributeByName(EAttribute attribute, | ||
83 | String sourceVariable, | ||
84 | String targetVariable, | ||
85 | Modality modality) | ||
86 | { | ||
87 | throw new UnsupportedOperationException | ||
88 | } | ||
89 | |||
90 | public def canonizeName(String name) { | ||
91 | name.split(' ').join('_') | ||
92 | } | ||
93 | |||
94 | public def lowerMultiplicities(LogicProblem problem) { | ||
95 | problem.assertions.map[annotations].flatten.filter(LowerMultiplicityAssertion).filter[!it.relation.isDerived] | ||
96 | } | ||
97 | public def wfQueries(LogicProblem problem) { | ||
98 | problem.assertions.map[it.annotations] | ||
99 | .flatten | ||
100 | .filter(TransformedViatraWellformednessConstraint) | ||
101 | .map[it.query] | ||
102 | } | ||
103 | public def getContainments(LogicProblem p) { | ||
104 | return p.containmentHierarchies.head.containmentRelations | ||
105 | } | ||
106 | public def getInverseRelations(LogicProblem p) { | ||
107 | val inverseRelations = new HashMap | ||
108 | p.annotations.filter(InverseRelationAssertion).forEach[ | ||
109 | inverseRelations.put(it.inverseA,it.inverseB) | ||
110 | inverseRelations.put(it.inverseB,it.inverseA) | ||
111 | ] | ||
112 | return inverseRelations | ||
113 | } | ||
114 | public def isRepresentative(Relation relation, Relation inverse) { | ||
115 | if(inverse == null) { | ||
116 | return true | ||
117 | } else { | ||
118 | relation.name.compareTo(inverse.name)<1 | ||
119 | } | ||
120 | } | ||
121 | |||
122 | public def isDerived(Relation relation) { | ||
123 | relation.annotations.exists[it instanceof DefinedByDerivedFeature] | ||
124 | } | ||
125 | public def getDerivedDefinition(RelationDeclaration relation) { | ||
126 | relation.annotations.filter(DefinedByDerivedFeature).head.query | ||
127 | } | ||
128 | |||
129 | public def transformBaseProperties( | ||
130 | LogicProblem problem, | ||
131 | PartialInterpretation emptySolution, | ||
132 | Map<String,PQuery> fqn2PQuery, | ||
133 | TypeAnalysisResult typeAnalysisResult | ||
134 | ) { | ||
135 | |||
136 | return ''' | ||
137 | import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" | ||
138 | import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" | ||
139 | import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" | ||
140 | |||
141 | ////////// | ||
142 | // 0. Util | ||
143 | ////////// | ||
144 | private pattern interpretation(problem:LogicProblem, interpetation:PartialInterpretation) { | ||
145 | PartialInterpretation.problem(interpetation,problem); | ||
146 | } | ||
147 | |||
148 | ///////////////////////// | ||
149 | // 0.1 Existance | ||
150 | ///////////////////////// | ||
151 | private pattern mustExist(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement) { | ||
152 | find interpretation(problem,interpetation); | ||
153 | LogicProblem.elements(problem,element); | ||
154 | } or { | ||
155 | find interpretation(problem,interpetation); | ||
156 | PartialInterpretation.newElements(interpetation,element); | ||
157 | } | ||
158 | |||
159 | private pattern mayExist(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement) { | ||
160 | find mustExist(problem,interpetation,element); | ||
161 | } or { | ||
162 | find interpretation(problem,interpetation); | ||
163 | neg find closeWorld(interpetation); | ||
164 | PartialInterpretation.openWorldElementPrototype(interpetation,element); | ||
165 | } | ||
166 | |||
167 | private pattern closeWorld(interpetation:PartialInterpretation) { | ||
168 | PartialInterpretation.maxNewElements(interpetation,0); | ||
169 | } | ||
170 | |||
171 | //////////////////////// | ||
172 | // 0.2 Equivalence | ||
173 | //////////////////////// | ||
174 | pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { | ||
175 | find mayExist(problem,interpretation,a); | ||
176 | find mayExist(problem,interpretation,b); | ||
177 | a == b; | ||
178 | } | ||
179 | |||
180 | //////////////////////// | ||
181 | // 0.3 Required Patterns by TypeIndexer | ||
182 | //////////////////////// | ||
183 | «typeIndexer.requiredQueries» | ||
184 | |||
185 | ////////// | ||
186 | // 1. Problem-Specific Base Indexers | ||
187 | ////////// | ||
188 | // 1.1 Type Indexers | ||
189 | ////////// | ||
190 | «typeIndexer.generateInstanceOfQueries(problem,emptySolution,typeAnalysisResult)» | ||
191 | |||
192 | ////////// | ||
193 | // 1.2 Relation Declaration Indexers | ||
194 | ////////// | ||
195 | «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),fqn2PQuery)» | ||
196 | |||
197 | ////////// | ||
198 | // 1.3 Relation Definition Indexers | ||
199 | ////////// | ||
200 | «relationDefinitionIndexer.generateRelationDefinitions(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)» | ||
201 | |||
202 | ////////// | ||
203 | // 1.4 Containment Indexer | ||
204 | ////////// | ||
205 | «containmentIndexer.transformContainment(problem,problem.relations,fqn2PQuery)» | ||
206 | |||
207 | ////////// | ||
208 | // 2. Invalidation Indexers | ||
209 | ////////// | ||
210 | // 2.1 Invalidated by WF Queries | ||
211 | ////////// | ||
212 | «invalidIndexer.generateInvalidatedByWfQueries(problem,fqn2PQuery)» | ||
213 | |||
214 | ////////// | ||
215 | // 3. Unfinishedness Indexers | ||
216 | ////////// | ||
217 | // 3.1 Unfinishedness Measured by Multiplicity | ||
218 | ////////// | ||
219 | «unfinishedIndexer.generateUnfinishedMultiplicityQueries(problem,fqn2PQuery)» | ||
220 | |||
221 | ////////// | ||
222 | // 3.2 Unfinishedness Measured by WF Queries | ||
223 | ////////// | ||
224 | «unfinishedIndexer.generateUnfinishedWfQueries(problem,fqn2PQuery)» | ||
225 | |||
226 | ////////// | ||
227 | // 4. Refinement Indexers | ||
228 | ////////// | ||
229 | // 4.1 Object constructors | ||
230 | ////////// | ||
231 | «typeRefinementGenerator.generateRefineObjectQueries(problem,emptySolution,typeAnalysisResult)» | ||
232 | |||
233 | ////////// | ||
234 | // 4.2 Type refinement | ||
235 | ////////// | ||
236 | «typeRefinementGenerator.generateRefineTypeQueries(problem,emptySolution,typeAnalysisResult)» | ||
237 | |||
238 | ////////// | ||
239 | // 4.3 Relation refinement | ||
240 | ////////// | ||
241 | «relationRefinementGenerator.generateRefineReference(problem)» | ||
242 | ''' | ||
243 | } | ||
244 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend new file mode 100644 index 00000000..dac5630b --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend | |||
@@ -0,0 +1,96 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysis | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
10 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.util.ParseUtil | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
13 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | ||
14 | import java.util.Map | ||
15 | import org.eclipse.viatra.query.runtime.api.IPatternMatch | ||
16 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
17 | import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher | ||
18 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
19 | import org.eclipse.xtend.lib.annotations.Data | ||
20 | |||
21 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
22 | |||
23 | @Data class GeneratedPatterns { | ||
24 | public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries | ||
25 | public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries | ||
26 | public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedMulticiplicityQueries | ||
27 | public Map<ObjectCreationPrecondition, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries | ||
28 | public Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries | ||
29 | public Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries | ||
30 | } | ||
31 | |||
32 | class PatternProvider { | ||
33 | val ParseUtil parseUtil = new ParseUtil | ||
34 | val TypeAnalysis typeAnalysis = new TypeAnalysis | ||
35 | |||
36 | public def generateQueries( | ||
37 | LogicProblem problem, | ||
38 | PartialInterpretation emptySolution, | ||
39 | ModelGenerationStatistics statistics, | ||
40 | Iterable<PQuery> existingQueries, | ||
41 | ReasonerWorkspace workspace, | ||
42 | TypeInferenceMethod typeInferenceMethod | ||
43 | ) { | ||
44 | val fqn2Query = existingQueries.toMap[it.fullyQualifiedName] | ||
45 | val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod) | ||
46 | val typeAnalysisResult = if(patternGenerator.requiresTypeAnalysis) { | ||
47 | val startTime = System.nanoTime | ||
48 | val result = typeAnalysis.performTypeAnalysis(problem,emptySolution) | ||
49 | val typeAnalysisTime = System.nanoTime - startTime | ||
50 | statistics.PreliminaryTypeAnalisisTime = typeAnalysisTime | ||
51 | result | ||
52 | } else { | ||
53 | null | ||
54 | } | ||
55 | val baseIndexerFile = patternGenerator.transformBaseProperties(problem,emptySolution,fqn2Query,typeAnalysisResult) | ||
56 | writeQueries(baseIndexerFile,"GeneratedQueries",workspace) | ||
57 | val generatedQueries = parseUtil.parse(baseIndexerFile) | ||
58 | val runtimeQueries = calclulateRuntimeQueries(patternGenerator,problem,emptySolution,typeAnalysisResult,generatedQueries); | ||
59 | return runtimeQueries | ||
60 | } | ||
61 | |||
62 | private def writeQueries(CharSequence content, String name,ReasonerWorkspace workspace) { | ||
63 | if(workspace!=null) { | ||
64 | workspace.writeText('''«name».vql_deactivated''',content) | ||
65 | } | ||
66 | } | ||
67 | |||
68 | private def GeneratedPatterns calclulateRuntimeQueries( | ||
69 | PatternGenerator patternGenerator, | ||
70 | LogicProblem problem, | ||
71 | PartialInterpretation emptySolution, | ||
72 | TypeAnalysisResult typeAnalysisResult, | ||
73 | Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries | ||
74 | ) { | ||
75 | val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
76 | invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)] | ||
77 | val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
78 | unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)] | ||
79 | val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
80 | unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)] | ||
81 | val Map<ObjectCreationPrecondition, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
82 | refineObjectsQueries = patternGenerator.typeRefinementGenerator.getRefineObjectQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)] | ||
83 | val Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
84 | refineTypeQueries = patternGenerator.typeRefinementGenerator.getRefineTypeQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)] | ||
85 | val Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> | ||
86 | refineRelationQueries = patternGenerator.relationRefinementGenerator.getRefineRelationQueries(problem).mapValues[it.lookup(queries)] | ||
87 | return new GeneratedPatterns( | ||
88 | invalidWFQueries, | ||
89 | unfinishedWFQueries, | ||
90 | unfinishedMultiplicityQueries, | ||
91 | refineObjectsQueries, | ||
92 | refineTypeQueries, | ||
93 | refineRelationQueries | ||
94 | ) | ||
95 | } | ||
96 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend new file mode 100644 index 00000000..e6d92cc6 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend | |||
@@ -0,0 +1,154 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
10 | import java.util.HashMap | ||
11 | import java.util.List | ||
12 | import java.util.Map | ||
13 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
14 | |||
15 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
16 | |||
17 | class RelationDeclarationIndexer { | ||
18 | val PatternGenerator base; | ||
19 | |||
20 | new(PatternGenerator base) { | ||
21 | this.base = base | ||
22 | } | ||
23 | |||
24 | public def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations, Map<String,PQuery> fqn2PQuery) { | ||
25 | val upperMultiplicities = new HashMap | ||
26 | problem.annotations.filter(UpperMultiplicityAssertion).forEach[ | ||
27 | upperMultiplicities.put(it.relation,it.upper) | ||
28 | ] | ||
29 | |||
30 | return ''' | ||
31 | «FOR relation : relations» | ||
32 | «IF base.isDerived(relation)» | ||
33 | «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))» | ||
34 | «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))» | ||
35 | «ELSE» | ||
36 | «generateMustRelation(problem,relation)» | ||
37 | «generateMayRelation(problem,relation,upperMultiplicities,base.getContainments(problem),base.getInverseRelations(problem),fqn2PQuery)» | ||
38 | «ENDIF» | ||
39 | «ENDFOR» | ||
40 | ''' | ||
41 | } | ||
42 | |||
43 | def private patternName(RelationDeclaration r, Modality modality) { | ||
44 | '''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»''' | ||
45 | } | ||
46 | |||
47 | public def referRelation( | ||
48 | RelationDeclaration referred, | ||
49 | String sourceVariable, | ||
50 | String targetVariable, | ||
51 | Modality modality) | ||
52 | '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);''' | ||
53 | |||
54 | def generateMustRelation(LogicProblem problem, RelationDeclaration relation) ''' | ||
55 | /** | ||
56 | * Matcher for detecting tuples t where []«relation.name»(source,target) | ||
57 | */ | ||
58 | private pattern «relation.patternName(Modality.MUST)»( | ||
59 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
60 | source: DefinedElement, target:DefinedElement) | ||
61 | { | ||
62 | find interpretation(problem,interpretation); | ||
63 | PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); | ||
64 | PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relation.name»"); | ||
65 | PartialRelationInterpretation.relationlinks(relationIterpretation,link); | ||
66 | BinaryElementRelationLink.param1(link,source); | ||
67 | BinaryElementRelationLink.param2(link,target); | ||
68 | } | ||
69 | ''' | ||
70 | def generateMayRelation(LogicProblem problem, RelationDeclaration relation, | ||
71 | Map<Relation, Integer> upperMultiplicities, | ||
72 | List<Relation> containments, | ||
73 | HashMap<Relation, Relation> inverseRelations, | ||
74 | Map<String,PQuery> fqn2PQuery) | ||
75 | { | ||
76 | return ''' | ||
77 | /** | ||
78 | * Matcher for detecting tuples t where <>«relation.name»(source,target) | ||
79 | */ | ||
80 | private pattern «relation.patternName(Modality.MAY)»( | ||
81 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
82 | source: DefinedElement, target:DefinedElement) | ||
83 | { | ||
84 | find interpretation(problem,interpretation); | ||
85 | // The two endpoint of the link have to exist | ||
86 | find mayExist(problem, interpretation, source); | ||
87 | find mayExist(problem, interpretation, target); | ||
88 | // Type consistency | ||
89 | «transformTypeConsistency(relation.parameters.get(0),"source")» | ||
90 | «transformTypeConsistency(relation.parameters.get(1),"target")» | ||
91 | «IF upperMultiplicities.containsKey(relation)» | ||
92 | // There are "numberOfExistingReferences" currently existing instances of the reference from the source, | ||
93 | // the upper bound of the multiplicity should be considered. | ||
94 | numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)» | ||
95 | check(numberOfExistingReferences < «upperMultiplicities.get(relation)»); | ||
96 | «ENDIF» | ||
97 | «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))» | ||
98 | // There are "numberOfExistingReferences" currently existing instances of the reference to the target, | ||
99 | // the upper bound of the opposite reference multiplicity should be considered. | ||
100 | numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)» | ||
101 | check(numberOfExistingOppositeReferences < «upperMultiplicities.get(inverseRelations.get(relation))»); | ||
102 | «ENDIF» | ||
103 | «IF containments.contains(relation)» | ||
104 | // The reference is containment, then a new reference cannot be create if: | ||
105 | // 1. Multiple parents | ||
106 | neg «base.containmentIndexer.referMustContaint("_","target")» | ||
107 | // 2. Circle in the containment hierarchy | ||
108 | neg «base.containmentIndexer.referTransitiveMustContains("target","source")» | ||
109 | «ENDIF» | ||
110 | «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))» | ||
111 | // The eOpposite of the reference is containment, then a referene cannot be created if | ||
112 | // 1. Multiple parents | ||
113 | neg «base.containmentIndexer.referMustContaint("source","_")» | ||
114 | // 2. Circle in the containment hierarchy | ||
115 | neg «base.containmentIndexer.referTransitiveMustContains("source","target")» | ||
116 | «ENDIF» | ||
117 | } or { | ||
118 | «relation.referRelation("source","target",Modality.MUST)» | ||
119 | } | ||
120 | ''' | ||
121 | } | ||
122 | |||
123 | def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) ''' | ||
124 | /** | ||
125 | * Matcher for detecting tuples t where []«relation.name»(source,target) | ||
126 | */ | ||
127 | private pattern «relation.patternName(Modality.MUST)»( | ||
128 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
129 | source: DefinedElement, target:DefinedElement) | ||
130 | { | ||
131 | «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)» | ||
132 | } | ||
133 | ''' | ||
134 | def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) ''' | ||
135 | /** | ||
136 | * Matcher for detecting tuples t where []«relation.name»(source,target) | ||
137 | */ | ||
138 | private pattern «relation.patternName(Modality.MAY)»( | ||
139 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
140 | source: DefinedElement, target:DefinedElement) | ||
141 | { | ||
142 | «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)» | ||
143 | } | ||
144 | ''' | ||
145 | |||
146 | protected def CharSequence transformTypeConsistency(TypeReference reference, String name) { | ||
147 | if(reference instanceof ComplexTypeReference) { | ||
148 | this.base.typeIndexer.referInstanceOf(reference.referred,Modality.MAY,name) | ||
149 | } else { | ||
150 | return '''// Primitive type of «name» is already enforced''' | ||
151 | } | ||
152 | |||
153 | } | ||
154 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend new file mode 100644 index 00000000..7792eccb --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend | |||
@@ -0,0 +1,185 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
5 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery | ||
6 | import java.util.Map | ||
7 | import org.eclipse.emf.ecore.EAttribute | ||
8 | import org.eclipse.emf.ecore.EReference | ||
9 | import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey | ||
10 | import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey | ||
11 | import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint | ||
12 | import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable | ||
13 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality | ||
14 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter | ||
15 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality | ||
16 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall | ||
17 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure | ||
18 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue | ||
19 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall | ||
20 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint | ||
21 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
22 | |||
23 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
24 | import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey | ||
25 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
26 | |||
27 | class RelationDefinitionIndexer { | ||
28 | val PatternGenerator base; | ||
29 | |||
30 | new(PatternGenerator base) { | ||
31 | this.base = base | ||
32 | } | ||
33 | |||
34 | public def generateRelationDefinitions( | ||
35 | LogicProblem problem, | ||
36 | Iterable<RelationDefinition> relations, | ||
37 | Map<String,PQuery> fqn2PQuery) { | ||
38 | val relation2PQuery = relations.toInvertedMap[ | ||
39 | annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery) | ||
40 | ] | ||
41 | |||
42 | return ''' | ||
43 | «FOR relation : relations» | ||
44 | // Must, May and Current queries for «relation.name» | ||
45 | «relation.transformPattern(relation.lookup(relation2PQuery), Modality.MUST)» | ||
46 | «relation.transformPattern(relation.lookup(relation2PQuery), Modality.MAY)» | ||
47 | «relation.transformPattern(relation.lookup(relation2PQuery), Modality.CURRENT)» | ||
48 | «ENDFOR» | ||
49 | ''' | ||
50 | } | ||
51 | |||
52 | private def relationDefinitionName(RelationDefinition relation, Modality modality) | ||
53 | '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»''' | ||
54 | |||
55 | private def canonizeName(PVariable v) { | ||
56 | return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»''' | ||
57 | } | ||
58 | |||
59 | private def transformPattern(RelationDefinition relation, PQuery p, Modality modality) { | ||
60 | try { | ||
61 | return ''' | ||
62 | private pattern «relationDefinitionName(relation,modality)»( | ||
63 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
64 | «FOR param : p.parameters SEPARATOR ', '»var_«param.name»«ENDFOR») | ||
65 | «FOR body : p.disjunctBodies.bodies SEPARATOR "or"»{ | ||
66 | find interpretation(problem,interpretation); | ||
67 | «FOR constraint : body.constraints» | ||
68 | «constraint.transformConstraint(modality)» | ||
69 | «ENDFOR» | ||
70 | }«ENDFOR» | ||
71 | ''' | ||
72 | } catch(UnsupportedOperationException e) { | ||
73 | throw new UnsupportedOperationException('''Can not transform pattern "«p.fullyQualifiedName»"!''',e) | ||
74 | } | ||
75 | } | ||
76 | |||
77 | private def toMustMay(Modality modality) { | ||
78 | if(modality == Modality::MAY) return Modality::MAY | ||
79 | else return Modality::MUST | ||
80 | } | ||
81 | |||
82 | def public referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) ''' | ||
83 | «IF !positive»neg «ENDIF»find «modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(problem,interpretation,«variables.join(',')»); | ||
84 | ''' | ||
85 | |||
86 | private dispatch def transformConstraint(TypeConstraint constraint, Modality modality) { | ||
87 | val touple = constraint.variablesTuple | ||
88 | if(touple.size == 1) { | ||
89 | val inputKey = constraint.equivalentJudgement.inputKey | ||
90 | if(inputKey instanceof EClassTransitiveInstancesKey) { | ||
91 | return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay, | ||
92 | constraint.getVariableInTuple(0).canonizeName) | ||
93 | } else if(inputKey instanceof EDataTypeInSlotsKey){ | ||
94 | return '''// type constraint is enforced by construction''' | ||
95 | } | ||
96 | |||
97 | } else if(touple.size == 2){ | ||
98 | val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey | ||
99 | if(key instanceof EReference) { | ||
100 | return base.referRelationByName( | ||
101 | key, | ||
102 | constraint.getVariableInTuple(0).canonizeName, | ||
103 | constraint.getVariableInTuple(1).canonizeName, | ||
104 | modality.toMustMay) | ||
105 | } else if (key instanceof EAttribute) { | ||
106 | return '''// attribute reference omitted'''//base.referRelationByName() | ||
107 | } else throw new UnsupportedOperationException('''unknown key: «key.class»''') | ||
108 | } else { | ||
109 | throw new UnsupportedOperationException() | ||
110 | } | ||
111 | } | ||
112 | |||
113 | private dispatch def transformConstraint(Equality equality, Modality modality) { | ||
114 | val a = equality.who | ||
115 | val b = equality.withWhom | ||
116 | transformEquality(modality.toMustMay, a, b) | ||
117 | } | ||
118 | |||
119 | private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) { | ||
120 | if(modality.isMustOrCurrent) '''«a.canonizeName» == «b.canonizeName»;''' | ||
121 | else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
122 | } | ||
123 | |||
124 | private dispatch def transformConstraint(Inequality inequality, Modality modality) { | ||
125 | val a = inequality.who | ||
126 | val b = inequality.withWhom | ||
127 | if(modality.isCurrent) { | ||
128 | return '''«a.canonizeName» != «b.canonizeName»;''' | ||
129 | } else if(modality.isMust) { | ||
130 | return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
131 | } else { | ||
132 | return '''«a.canonizeName» != «b.canonizeName»;''' | ||
133 | } | ||
134 | } | ||
135 | |||
136 | private dispatch def transformConstraint(NegativePatternCall pcall, Modality modality) { | ||
137 | val params = (0..<pcall.actualParametersTuple.size).map[index | | ||
138 | val variable = pcall.actualParametersTuple.get(index) as PVariable | ||
139 | return variable.canonizeName | ||
140 | ] | ||
141 | return referPattern(pcall.referredQuery,params,modality.dual,false,false) | ||
142 | } | ||
143 | |||
144 | private dispatch def transformConstraint(PositivePatternCall pcall, Modality modality) { | ||
145 | val params = (0..<pcall.variablesTuple.size).map[index | | ||
146 | val variable = pcall.variablesTuple.get(index) as PVariable | ||
147 | return variable.canonizeName | ||
148 | ] | ||
149 | return referPattern(pcall.referredQuery,params,modality,true,false) | ||
150 | } | ||
151 | private dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality) { | ||
152 | val params = (0..1).map[index | | ||
153 | val variable = pcall.getVariableInTuple(index) as PVariable | ||
154 | return variable.canonizeName | ||
155 | ] | ||
156 | return referPattern(pcall.referredQuery,params,modality,true,true) | ||
157 | } | ||
158 | private dispatch def transformConstraint(ExportedParameter e, Modality modality) { | ||
159 | return '''// «e.parameterName» is exported''' | ||
160 | } | ||
161 | private dispatch def transformConstraint(ConstantValue c, Modality modality) { | ||
162 | val target = c.supplierKey | ||
163 | |||
164 | var String targetString; | ||
165 | var String additionalDefinition; | ||
166 | if(target instanceof Enum<?>) { | ||
167 | targetString = '''const_«target.name»_«target.declaringClass.simpleName»''' | ||
168 | additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.declaringClass.simpleName»"); LogicProblem.elements(problem,«targetString»);''' | ||
169 | } else if(target instanceof Integer) { | ||
170 | targetString = target.toString | ||
171 | additionalDefinition = '''''' | ||
172 | } else throw new UnsupportedOperationException('''Unknown constant type: «target.class»''') | ||
173 | |||
174 | val source = c.variablesTuple | ||
175 | var String sourceName | ||
176 | if(source.size == 1) | ||
177 | sourceName = (source.get(0) as PVariable).canonizeName | ||
178 | else throw new UnsupportedOperationException("unknown source") | ||
179 | return '''«sourceName» == «targetString»;«additionalDefinition»'''; | ||
180 | } | ||
181 | |||
182 | private dispatch def transformConstraint(PConstraint c, Modality modality) { | ||
183 | throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''') | ||
184 | } | ||
185 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend new file mode 100644 index 00000000..7b175227 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend | |||
@@ -0,0 +1,93 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
7 | import java.util.LinkedList | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
9 | |||
10 | class RelationRefinementGenerator { | ||
11 | PatternGenerator base; | ||
12 | public new(PatternGenerator base) { | ||
13 | this.base = base | ||
14 | } | ||
15 | |||
16 | def CharSequence generateRefineReference(LogicProblem p) { | ||
17 | return ''' | ||
18 | «FOR relationRefinement: this.getRelationRefinements(p)» | ||
19 | pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»( | ||
20 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
21 | relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value != null», oppositeInterpretation:PartialRelationInterpretation«ENDIF», | ||
22 | from: DefinedElement, to: DefinedElement) | ||
23 | { | ||
24 | find interpretation(problem,interpretation); | ||
25 | PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); | ||
26 | PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»"); | ||
27 | «IF relationRefinement.value != null» | ||
28 | PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); | ||
29 | PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»"); | ||
30 | «ENDIF» | ||
31 | find mustExist(problem, interpretation, from); | ||
32 | find mustExist(problem, interpretation, to); | ||
33 | «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(0) as ComplexTypeReference).referred, Modality::MUST,"from")» | ||
34 | «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(1) as ComplexTypeReference).referred, Modality::MUST,"to")» | ||
35 | «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)» | ||
36 | neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)» | ||
37 | } | ||
38 | «ENDFOR» | ||
39 | ''' | ||
40 | } | ||
41 | |||
42 | def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) { | ||
43 | '''«IF inverseRelation != null | ||
44 | »refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»« | ||
45 | ELSE | ||
46 | »refineRelation_«base.canonizeName(relation.name)»«ENDIF»''' | ||
47 | } | ||
48 | |||
49 | def referRefinementQuery(RelationDeclaration relation, Relation inverseRelation, String relInterpretationName, | ||
50 | String inverseInterpretationName, String sourceName, String targetName) | ||
51 | '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation != null»inverseInterpretationName, «ENDIF»«sourceName», «targetName»);''' | ||
52 | |||
53 | def getRefineRelationQueries(LogicProblem p) { | ||
54 | // val containmentRelations = p.containmentHierarchies.map[containmentRelations].flatten.toSet | ||
55 | // p.relations.filter(RelationDeclaration).filter[!containmentRelations.contains(it)].toInvertedMap['''refineRelation_«base.canonizeName(it.name)»'''] | ||
56 | /* | ||
57 | val res = new LinkedHashMap | ||
58 | for(relation: getRelationRefinements(p)) { | ||
59 | if(inverseRelations.containsKey(relation)) { | ||
60 | val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»''' | ||
61 | res.put(relation -> inverseRelations.get(relation),name) | ||
62 | } else { | ||
63 | val name = '''refineRelation_«base.canonizeName(relation.name)»''' | ||
64 | res.put(relation -> null,name) | ||
65 | } | ||
66 | } | ||
67 | return res*/ | ||
68 | |||
69 | getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key,it.value)] | ||
70 | } | ||
71 | |||
72 | |||
73 | def getRelationRefinements(LogicProblem p) { | ||
74 | val inverses = base.getInverseRelations(p) | ||
75 | val containments = base.getContainments(p) | ||
76 | val list = new LinkedList | ||
77 | for(relation : p.relations.filter(RelationDeclaration)) { | ||
78 | if(!containments.contains(relation)) { | ||
79 | if(inverses.containsKey(relation)) { | ||
80 | val inverse = inverses.get(relation) | ||
81 | if(!containments.contains(inverse)) { | ||
82 | if(base.isRepresentative(relation,inverse)) { | ||
83 | list += (relation -> inverse) | ||
84 | } | ||
85 | } | ||
86 | } else { | ||
87 | list += (relation -> null) | ||
88 | } | ||
89 | } | ||
90 | } | ||
91 | return list | ||
92 | } | ||
93 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend new file mode 100644 index 00000000..30fe5878 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend | |||
@@ -0,0 +1,18 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
4 | |||
5 | class RepairGenerator { | ||
6 | val PatternGenerator base; | ||
7 | new(PatternGenerator base) { | ||
8 | this.base = base | ||
9 | } | ||
10 | |||
11 | def generateRepairUnfinishedMultiplicityPatterns(LogicProblem problem) { | ||
12 | //val refinements = base.relationRefinementGenerator.getRelationRefinements(problem) | ||
13 | //val unfinisedLowerMultiplicities = base.get | ||
14 | } | ||
15 | def getRepairUnfinishedMultiplicityPatterns() { | ||
16 | |||
17 | } | ||
18 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend new file mode 100644 index 00000000..6c450664 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend | |||
@@ -0,0 +1,16 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import org.eclipse.emf.ecore.EClass | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
9 | |||
10 | interface TypeIndexer { | ||
11 | public def CharSequence getRequiredQueries() | ||
12 | public def boolean requiresTypeAnalysis() | ||
13 | public def CharSequence generateInstanceOfQueries(LogicProblem problem,PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult) | ||
14 | public def CharSequence referInstanceOf(Type type, Modality modality, String variableName) | ||
15 | public def CharSequence referInstanceOf(EClass type, Modality modality, String variableName) | ||
16 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend new file mode 100644 index 00000000..3c49c323 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend | |||
@@ -0,0 +1,97 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
8 | import org.eclipse.emf.ecore.EClass | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeRefinementPrecondition | ||
10 | import java.util.Collections | ||
11 | |||
12 | class TypeIndexerWithPreliminaryTypeAnalysis implements TypeIndexer{ | ||
13 | val PatternGenerator base; | ||
14 | |||
15 | new(PatternGenerator base) { | ||
16 | this.base = base | ||
17 | } | ||
18 | override requiresTypeAnalysis() { true } | ||
19 | |||
20 | override getRequiredQueries() ''' | ||
21 | private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialTypeInterpratation) { | ||
22 | find interpretation(problem,interpetation); | ||
23 | LogicProblem.types(problem,type); | ||
24 | PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation); | ||
25 | PartialTypeInterpratation.interpretationOf(typeInterpretation,type); | ||
26 | } | ||
27 | |||
28 | private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) { | ||
29 | find interpretation(problem,interpetation); | ||
30 | LogicProblem.types(problem,type); | ||
31 | TypeDefinition.elements(type,element); | ||
32 | } or { | ||
33 | find interpretation(problem,interpetation); | ||
34 | find typeInterpretation(problem,interpetation,type,typeInterpretation); | ||
35 | PartialTypeInterpratation.elements(typeInterpretation,element); | ||
36 | } | ||
37 | ''' | ||
38 | |||
39 | override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
40 | val mayNewTypePreconditions = typeAnalysisResult.mayNewTypePreconditions | ||
41 | |||
42 | return ''' | ||
43 | «FOR type:problem.types» | ||
44 | «problem.generateMustInstenceOf(type)» | ||
45 | «problem.generateMayInstanceOf(type,mayNewTypePreconditions.get(type))» | ||
46 | «ENDFOR» | ||
47 | ''' | ||
48 | } | ||
49 | |||
50 | private def patternName(Type type, Modality modality) | ||
51 | '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»''' | ||
52 | |||
53 | private def generateMustInstenceOf(LogicProblem problem, Type type) { | ||
54 | ''' | ||
55 | /** | ||
56 | * An element must be an instance of type "«type.name»". | ||
57 | */ | ||
58 | private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { | ||
59 | Type.name(type,"«type.name»"); | ||
60 | find directInstanceOf(problem,interpretation,element,type); | ||
61 | } | ||
62 | ''' | ||
63 | } | ||
64 | |||
65 | private def generateMayInstanceOf(LogicProblem problem, Type type, TypeRefinementPrecondition precondition) { | ||
66 | val inhibitorTypes = if(precondition!=null) { | ||
67 | precondition.inhibitorTypes | ||
68 | } else { | ||
69 | null | ||
70 | } | ||
71 | ''' | ||
72 | /** | ||
73 | * An element may be an instance of type "«type.name»". | ||
74 | */ | ||
75 | private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) | ||
76 | «IF inhibitorTypes != null»{ | ||
77 | find interpretation(problem,interpretation); | ||
78 | PartialInterpretation.newElements(interpretation,element); | ||
79 | «FOR inhibitorType : inhibitorTypes» | ||
80 | neg «referInstanceOf(inhibitorType,Modality.MUST,"element")» | ||
81 | «ENDFOR» | ||
82 | } or { | ||
83 | find interpretation(problem,interpretation); | ||
84 | PartialInterpretation.openWorldElementPrototype(interpetation,element); | ||
85 | } or | ||
86 | «ENDIF» | ||
87 | { «referInstanceOf(type,Modality.MUST,"element")» } | ||
88 | ''' | ||
89 | } | ||
90 | |||
91 | public override referInstanceOf(Type type, Modality modality, String variableName) { | ||
92 | '''find «patternName(type,modality)»(problem,interpretation,«variableName»);''' | ||
93 | } | ||
94 | public override referInstanceOf(EClass type, Modality modality, String variableName) { | ||
95 | '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''class «type.name»''')»(problem,interpretation,«variableName»);''' | ||
96 | } | ||
97 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend new file mode 100644 index 00000000..a9ce9d73 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend | |||
@@ -0,0 +1,95 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
8 | import java.util.Map | ||
9 | import org.eclipse.xtend.lib.annotations.Data | ||
10 | import java.util.HashMap | ||
11 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion | ||
12 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration | ||
13 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
14 | import java.util.LinkedHashMap | ||
15 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
16 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy | ||
17 | |||
18 | @Data | ||
19 | class ObjectCreationPrecondition { | ||
20 | Relation containmentRelation | ||
21 | Relation inverseContainment | ||
22 | Type newType | ||
23 | } | ||
24 | |||
25 | abstract class TypeRefinementGenerator { | ||
26 | val protected PatternGenerator base; | ||
27 | public new(PatternGenerator base) { | ||
28 | this.base = base | ||
29 | } | ||
30 | |||
31 | public def boolean requiresTypeAnalysis() | ||
32 | public def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) | ||
33 | public def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) | ||
34 | public def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) | ||
35 | |||
36 | public def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
37 | val Map<ObjectCreationPrecondition,String> objectCreationQueries = new LinkedHashMap | ||
38 | val containment = p.containmentHierarchies.head | ||
39 | val inverseRelations = new HashMap | ||
40 | p.annotations.filter(InverseRelationAssertion).forEach[ | ||
41 | inverseRelations.put(it.inverseA,it.inverseB) | ||
42 | inverseRelations.put(it.inverseB,it.inverseA) | ||
43 | ] | ||
44 | for(type: p.types.filter(TypeDeclaration).filter[!it.isAbstract]) { | ||
45 | if(containment.typeInContainment(type)) { | ||
46 | for(containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]) { | ||
47 | if(inverseRelations.containsKey(containmentRelation)) { | ||
48 | objectCreationQueries.put( | ||
49 | new ObjectCreationPrecondition(containmentRelation,inverseRelations.get(containmentRelation),type), | ||
50 | this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)) | ||
51 | } else { | ||
52 | objectCreationQueries.put( | ||
53 | new ObjectCreationPrecondition(containmentRelation,null,type), | ||
54 | patternName(containmentRelation,null,type)) | ||
55 | } | ||
56 | } | ||
57 | } else { | ||
58 | objectCreationQueries.put( | ||
59 | new ObjectCreationPrecondition(null,null,type), | ||
60 | this.patternName(null,null,type)) | ||
61 | } | ||
62 | } | ||
63 | return objectCreationQueries | ||
64 | } | ||
65 | |||
66 | protected def canBeContainedByRelation(Relation r, Type t) { | ||
67 | if(r.parameters.size==2) { | ||
68 | val param = r.parameters.get(1) | ||
69 | if(param instanceof ComplexTypeReference) { | ||
70 | val allSuperTypes = t.transitiveClosureStar[it.supertypes] | ||
71 | for(superType : allSuperTypes) { | ||
72 | if(param.referred == superType) return true | ||
73 | } | ||
74 | } | ||
75 | } | ||
76 | return false | ||
77 | } | ||
78 | |||
79 | private def typeInContainment(ContainmentHierarchy hierarchy, Type type) { | ||
80 | val allSuperTypes = type.transitiveClosureStar[it.supertypes] | ||
81 | return allSuperTypes.exists[hierarchy.typesOrderedInHierarchy.contains(it)] | ||
82 | } | ||
83 | |||
84 | protected def String patternName(Relation containmentRelation, Relation inverseContainment, Type newType) { | ||
85 | if(containmentRelation != null) { | ||
86 | if(inverseContainment != null) { | ||
87 | '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»_with_«base.canonizeName(inverseContainment.name)»''' | ||
88 | } else { | ||
89 | '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»''' | ||
90 | } | ||
91 | } else { | ||
92 | '''createObject_«base.canonizeName(newType.name)»''' | ||
93 | } | ||
94 | } | ||
95 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend new file mode 100644 index 00000000..be54d63c --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend | |||
@@ -0,0 +1,105 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
10 | import java.util.HashMap | ||
11 | |||
12 | class TypeRefinementWithPreliminaryTypeAnalysis extends TypeRefinementGenerator{ | ||
13 | public new(PatternGenerator base) { | ||
14 | super(base) | ||
15 | } | ||
16 | override requiresTypeAnalysis() { true } | ||
17 | |||
18 | |||
19 | override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
20 | val possibleNewDynamicType = typeAnalysisResult.possibleNewDynamicTypes | ||
21 | val containment = p.containmentHierarchies.head | ||
22 | val inverseRelations = new HashMap | ||
23 | p.annotations.filter(InverseRelationAssertion).forEach[ | ||
24 | inverseRelations.put(it.inverseA,it.inverseB) | ||
25 | inverseRelations.put(it.inverseB,it.inverseA) | ||
26 | ] | ||
27 | return ''' | ||
28 | «FOR type:possibleNewDynamicType» | ||
29 | «IF(containment.typesOrderedInHierarchy.contains(type))» | ||
30 | «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]» | ||
31 | «IF inverseRelations.containsKey(containmentRelation)» | ||
32 | pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»( | ||
33 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
34 | relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation, | ||
35 | container:DefinedElement) | ||
36 | { | ||
37 | find interpretation(problem,interpretation); | ||
38 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
39 | PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»"); | ||
40 | PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); | ||
41 | PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»"); | ||
42 | PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); | ||
43 | PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»"); | ||
44 | «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")» | ||
45 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
46 | «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)» | ||
47 | find mustExist(problem, interpretation, container); | ||
48 | neg find mustExist(problem, interpretation, newObject); | ||
49 | } | ||
50 | «ELSE» | ||
51 | pattern «this.patternName(containmentRelation,null,type)»( | ||
52 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
53 | relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation, | ||
54 | container:DefinedElement) | ||
55 | { | ||
56 | find interpretation(problem,interpretation); | ||
57 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
58 | PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»"); | ||
59 | PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); | ||
60 | PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»"); | ||
61 | «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")» | ||
62 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
63 | «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)» | ||
64 | find mustExist(problem, interpretation, container); | ||
65 | neg find mustExist(problem, interpretation, newObject); | ||
66 | } | ||
67 | «ENDIF» | ||
68 | «ENDFOR» | ||
69 | «ELSE» | ||
70 | pattern createObject_«base.canonizeName(type.name)»( | ||
71 | problem:LogicProblem, interpretation:PartialInterpretation, | ||
72 | typeInterpretation:PartialTypeInterpratation) | ||
73 | { | ||
74 | find interpretation(problem,interpretation); | ||
75 | PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); | ||
76 | PartialTypeInterpratation.interpretationOf.name(type,"«type.name»"); | ||
77 | «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")» | ||
78 | find mayExist(problem, interpretation, newObject); | ||
79 | neg find mustExist(problem, interpretation, newObject); | ||
80 | } | ||
81 | «ENDIF» | ||
82 | «ENDFOR» | ||
83 | ''' | ||
84 | } | ||
85 | |||
86 | override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
87 | val newTypeRefinements = typeAnalysisResult.possibleNewTypeRefinements | ||
88 | return ''' | ||
89 | «FOR newTypeRefinement : newTypeRefinements» | ||
90 | pattern refineTypeTo_«base.canonizeName(newTypeRefinement.targetType.name)»(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { | ||
91 | find interpretation(problem,interpretation); | ||
92 | PartialInterpretation.newElements(interpretation,element); | ||
93 | «FOR inhibitorType : newTypeRefinement.inhibitorTypes» | ||
94 | neg «base.typeIndexer.referInstanceOf(inhibitorType,Modality.MUST,"element")» | ||
95 | «ENDFOR» | ||
96 | } | ||
97 | «ENDFOR» | ||
98 | ''' | ||
99 | } | ||
100 | |||
101 | override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) { | ||
102 | val newTypeRefinements = typeAnalysisResult.possibleNewTypeRefinements | ||
103 | newTypeRefinements.map[targetType].toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»'''] | ||
104 | } | ||
105 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend new file mode 100644 index 00000000..ad1c9033 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend | |||
@@ -0,0 +1,85 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
5 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint | ||
6 | import java.util.Map | ||
7 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | ||
8 | |||
9 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
10 | import java.util.LinkedHashMap | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | ||
12 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference | ||
13 | |||
14 | class UnfinishedIndexer { | ||
15 | val PatternGenerator base | ||
16 | |||
17 | new(PatternGenerator patternGenerator) { | ||
18 | this.base = patternGenerator | ||
19 | } | ||
20 | |||
21 | def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) { | ||
22 | val wfQueries = base.wfQueries(problem) | ||
23 | ''' | ||
24 | «FOR wfQuery: wfQueries» | ||
25 | pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation, | ||
26 | «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR») | ||
27 | { | ||
28 | «base.relationDefinitionIndexer.referPattern( | ||
29 | wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery), | ||
30 | wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''], | ||
31 | Modality.CURRENT, | ||
32 | true,false)» | ||
33 | } | ||
34 | «ENDFOR» | ||
35 | ''' | ||
36 | } | ||
37 | def getUnfinishedWFQueryNames(LogicProblem problem) { | ||
38 | val wfQueries = base.wfQueries(problem) | ||
39 | val map = new LinkedHashMap | ||
40 | for(wfQuery : wfQueries) { | ||
41 | map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''') | ||
42 | } | ||
43 | return map | ||
44 | } | ||
45 | def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) { | ||
46 | val lowerMultiplicities = base.lowerMultiplicities(problem) | ||
47 | return ''' | ||
48 | «FOR lowerMultiplicity : lowerMultiplicities» | ||
49 | pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { | ||
50 | find interpretation(problem,interpretation); | ||
51 | PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); | ||
52 | PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»"); | ||
53 | «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")» | ||
54 | numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)» | ||
55 | check(numberOfExistingReferences < «lowerMultiplicity.lower»); | ||
56 | missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences); | ||
57 | } | ||
58 | «ENDFOR» | ||
59 | ''' | ||
60 | } | ||
61 | def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) | ||
62 | '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»''' | ||
63 | |||
64 | def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion) | ||
65 | '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);''' | ||
66 | |||
67 | def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) { | ||
68 | val parameters = lowerMultiplicityAssertion.relation.parameters | ||
69 | if(parameters.size == 2) { | ||
70 | val firstParam = parameters.get(0) | ||
71 | if(firstParam instanceof ComplexTypeReference) { | ||
72 | return firstParam.referred | ||
73 | } | ||
74 | } | ||
75 | } | ||
76 | |||
77 | def getUnfinishedMultiplicityQueries(LogicProblem problem) { | ||
78 | val lowerMultiplicities = base.lowerMultiplicities(problem) | ||
79 | val map = new LinkedHashMap | ||
80 | for(lowerMultiplicity : lowerMultiplicities) { | ||
81 | map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)) | ||
82 | } | ||
83 | return map | ||
84 | } | ||
85 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend new file mode 100644 index 00000000..e1be2742 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend | |||
@@ -0,0 +1,18 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns | ||
5 | import java.util.ArrayList | ||
6 | |||
7 | class GoalConstraintProvider { | ||
8 | def public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) { | ||
9 | val multiplicityQueries = patterns.unfinishedMulticiplicityQueries | ||
10 | val res = new ArrayList(multiplicityQueries.size) | ||
11 | for(multiplicityQuery : multiplicityQueries.entrySet) { | ||
12 | val targetRelationName = multiplicityQuery.key.name | ||
13 | val query = multiplicityQuery.value | ||
14 | res += new MultiplicityGoalConstraintCalculator(targetRelationName,query); | ||
15 | } | ||
16 | return res | ||
17 | } | ||
18 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend new file mode 100644 index 00000000..8b0f8f85 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend | |||
@@ -0,0 +1,209 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics | ||
10 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ObjectCreationPrecondition | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
13 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation | ||
14 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation | ||
15 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory | ||
16 | import java.util.LinkedHashMap | ||
17 | import org.eclipse.viatra.query.runtime.api.GenericPatternMatch | ||
18 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
19 | import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher | ||
20 | import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule | ||
21 | import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory | ||
22 | |||
23 | class RefinementRuleProvider { | ||
24 | private extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory | ||
25 | private extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE | ||
26 | private extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE | ||
27 | |||
28 | def canonizeName(String name) { | ||
29 | return name.replace(' ','_') | ||
30 | } | ||
31 | |||
32 | def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> | ||
33 | createObjectRefinementRules( | ||
34 | GeneratedPatterns patterns, | ||
35 | boolean nameNewElement, | ||
36 | ModelGenerationStatistics statistics | ||
37 | ) | ||
38 | { | ||
39 | val res = new LinkedHashMap | ||
40 | for(LHSEntry: patterns.refineObjectQueries.entrySet) { | ||
41 | val containmentRelation = LHSEntry.key.containmentRelation | ||
42 | val inverseRelation = LHSEntry.key.inverseContainment | ||
43 | val type = LHSEntry.key.newType | ||
44 | val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> | ||
45 | val rule = createObjectCreationRule(containmentRelation,inverseRelation,type,lhs,nameNewElement,statistics) | ||
46 | res.put(LHSEntry.key,rule) | ||
47 | } | ||
48 | return res | ||
49 | } | ||
50 | |||
51 | def private createObjectCreationRule( | ||
52 | Relation containmentRelation, | ||
53 | Relation inverseRelation, | ||
54 | Type type, | ||
55 | IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, | ||
56 | boolean nameNewElement, | ||
57 | ModelGenerationStatistics statistics) | ||
58 | { | ||
59 | val name = '''addObject_«type.name.canonizeName»« | ||
60 | IF containmentRelation!=null»_by_«containmentRelation.name.canonizeName»«ENDIF»''' | ||
61 | val ruleBuilder = factory.createRule | ||
62 | .name(name) | ||
63 | .precondition(lhs) | ||
64 | if(containmentRelation != null) { | ||
65 | if(inverseRelation!= null) { | ||
66 | ruleBuilder.action[match | | ||
67 | //println(name) | ||
68 | val startTime = System.nanoTime | ||
69 | //val problem = match.get(0) as LogicProblem | ||
70 | val interpretation = match.get(1) as PartialInterpretation | ||
71 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
72 | val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation | ||
73 | val typeInterpretation = match.get(4) as PartialTypeInterpratation | ||
74 | val container = match.get(5) as DefinedElement | ||
75 | |||
76 | val newElement = createDefinedElement | ||
77 | if(nameNewElement) { | ||
78 | newElement.name = '''new «interpretation.newElements.size»''' | ||
79 | } | ||
80 | |||
81 | // Existence | ||
82 | interpretation.newElements+=newElement | ||
83 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
84 | if(interpretation.minNewElements > 0) { | ||
85 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
86 | } | ||
87 | |||
88 | // Types | ||
89 | typeInterpretation.elements += newElement | ||
90 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
91 | // ContainmentRelation | ||
92 | val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement] | ||
93 | relationInterpretation.relationlinks+=newLink1 | ||
94 | // Inverse Containment | ||
95 | val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container] | ||
96 | inverseRelationInterpretation.relationlinks+=newLink2 | ||
97 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
98 | ] | ||
99 | } else { | ||
100 | ruleBuilder.action[match | | ||
101 | //println(name) | ||
102 | val startTime = System.nanoTime | ||
103 | //val problem = match.get(0) as LogicProblem | ||
104 | val interpretation = match.get(1) as PartialInterpretation | ||
105 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
106 | val typeInterpretation = match.get(3) as PartialTypeInterpratation | ||
107 | val container = match.get(4) as DefinedElement | ||
108 | |||
109 | val newElement = createDefinedElement | ||
110 | if(nameNewElement) { | ||
111 | newElement.name = '''new «interpretation.newElements.size»''' | ||
112 | } | ||
113 | |||
114 | // Existence | ||
115 | interpretation.newElements+=newElement | ||
116 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
117 | if(interpretation.minNewElements > 0) { | ||
118 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
119 | } | ||
120 | |||
121 | // Types | ||
122 | typeInterpretation.elements += newElement | ||
123 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
124 | // ContainmentRelation | ||
125 | val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement] | ||
126 | relationInterpretation.relationlinks+=newLink | ||
127 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
128 | ] | ||
129 | } | ||
130 | } else { | ||
131 | ruleBuilder.action[match | | ||
132 | //println(name) | ||
133 | val startTime = System.nanoTime | ||
134 | //val problem = match.get(0) as LogicProblem | ||
135 | val interpretation = match.get(1) as PartialInterpretation | ||
136 | val typeInterpretation = match.get(2) as PartialTypeInterpratation | ||
137 | |||
138 | val newElement = createDefinedElement //=> [it.name = null] | ||
139 | if(nameNewElement) { | ||
140 | newElement.name = '''new «interpretation.newElements.size»''' | ||
141 | } | ||
142 | // Existence | ||
143 | interpretation.newElements+=newElement | ||
144 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
145 | if(interpretation.minNewElements > 0) { | ||
146 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
147 | } | ||
148 | // Types | ||
149 | typeInterpretation.elements += newElement | ||
150 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
151 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
152 | ] | ||
153 | } | ||
154 | return ruleBuilder.build | ||
155 | } | ||
156 | |||
157 | def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) { | ||
158 | val res = new LinkedHashMap | ||
159 | for(LHSEntry: patterns.refinerelationQueries.entrySet) { | ||
160 | val declaration = LHSEntry.key.key | ||
161 | val inverseReference = LHSEntry.key.value | ||
162 | val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> | ||
163 | val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics) | ||
164 | res.put(LHSEntry.key,rule) | ||
165 | } | ||
166 | return res | ||
167 | } | ||
168 | |||
169 | def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>> | ||
170 | createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics) | ||
171 | { | ||
172 | val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»''' | ||
173 | val ruleBuilder = factory.createRule | ||
174 | .name(name) | ||
175 | .precondition(lhs) | ||
176 | if (inverseRelation == null) { | ||
177 | ruleBuilder.action [ match | | ||
178 | val startTime = System.nanoTime | ||
179 | //println(name) | ||
180 | // val problem = match.get(0) as LogicProblem | ||
181 | // val interpretation = match.get(1) as PartialInterpretation | ||
182 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
183 | val src = match.get(3) as DefinedElement | ||
184 | val trg = match.get(4) as DefinedElement | ||
185 | val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg] | ||
186 | relationInterpretation.relationlinks += link | ||
187 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
188 | ] | ||
189 | } else { | ||
190 | ruleBuilder.action [ match | | ||
191 | val startTime = System.nanoTime | ||
192 | //println(name) | ||
193 | // val problem = match.get(0) as LogicProblem | ||
194 | // val interpretation = match.get(1) as PartialInterpretation | ||
195 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
196 | val inverseInterpretation = match.get(3) as PartialRelationInterpretation | ||
197 | val src = match.get(4) as DefinedElement | ||
198 | val trg = match.get(5) as DefinedElement | ||
199 | val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg] | ||
200 | relationInterpretation.relationlinks += link | ||
201 | val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src] | ||
202 | inverseInterpretation.relationlinks += inverseLink | ||
203 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
204 | ] | ||
205 | } | ||
206 | |||
207 | return ruleBuilder.build | ||
208 | } | ||
209 | } | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend new file mode 100644 index 00000000..005304ea --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend | |||
@@ -0,0 +1,89 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.util | ||
2 | |||
3 | import com.google.inject.Guice | ||
4 | import com.google.inject.Injector | ||
5 | import com.google.inject.Module | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage | ||
9 | import java.io.ByteArrayInputStream | ||
10 | import java.io.InputStream | ||
11 | import java.util.LinkedHashMap | ||
12 | import org.eclipse.emf.common.util.URI | ||
13 | import org.eclipse.emf.ecore.resource.Resource | ||
14 | import org.eclipse.emf.ecore.util.EcoreUtil | ||
15 | import org.eclipse.viatra.query.patternlanguage.PatternLanguageStandaloneSetup | ||
16 | import org.eclipse.viatra.query.patternlanguage.annotations.ExtensionBasedAnnotationValidatorLoader | ||
17 | import org.eclipse.viatra.query.patternlanguage.annotations.IAnnotationValidatorLoader | ||
18 | import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageRuntimeModule | ||
19 | import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup | ||
20 | import org.eclipse.viatra.query.patternlanguage.emf.GenmodelExtensionLoader | ||
21 | import org.eclipse.viatra.query.patternlanguage.emf.IGenmodelMappingLoader | ||
22 | import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel | ||
23 | import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder | ||
24 | import org.eclipse.xtext.resource.XtextResourceSet | ||
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 ParseUtil { | ||
36 | val Injector injector; | ||
37 | new() { | ||
38 | PatternLanguageStandaloneSetup.doSetup | ||
39 | EMFPatternLanguageStandaloneSetup.doSetup; | ||
40 | PartialinterpretationPackage.eINSTANCE.class; | ||
41 | LogicproblemPackage.eINSTANCE.class; | ||
42 | LogiclanguagePackage.eINSTANCE.class; | ||
43 | |||
44 | injector = internalCreateInjector//(new EMFPatternLanguageStandaloneSetup()).createInjectorAndDoEMFRegistration(); | ||
45 | } | ||
46 | |||
47 | def protected Injector internalCreateInjector() { | ||
48 | var newInjector = new EMFPatternLanguageStandaloneSetup().createInjectorAndDoEMFRegistration(); | ||
49 | //XXX the following line enforce the tests to be run in an Eclipse environment | ||
50 | val Module module = new MyModule | ||
51 | newInjector = Guice.createInjector(module) | ||
52 | //ViatraQueryLoggingUtil.setExternalLogger(newInjector.getInstance(Logger.class)); | ||
53 | //EMFPatternLanguagePlugin.getInstance().addCompoundInjector(newInjector,EMFPatternLanguagePlugin.TEST_INJECTOR_PRIORITY); | ||
54 | return newInjector; | ||
55 | } | ||
56 | |||
57 | // @Inject | ||
58 | // var ParseHelper<PatternModel> parseHelper; | ||
59 | val builder = new SpecificationBuilder | ||
60 | |||
61 | public def parse(CharSequence vqlFileContent) { | ||
62 | //val patternModel = this.parseHelper.parse(vqlFileContent) | ||
63 | val XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet); | ||
64 | val Resource resource = resourceSet.createResource(URI.createURI("dummy:/example.vql")); | ||
65 | val InputStream in = new ByteArrayInputStream(vqlFileContent.toString.getBytes()); | ||
66 | resource.load(in, resourceSet.getLoadOptions()); | ||
67 | val patternModel = resource.getContents().get(0) as PatternModel; | ||
68 | |||
69 | EcoreUtil.resolveAll(resource) | ||
70 | resource.validate | ||
71 | val res = new LinkedHashMap | ||
72 | for(pattern : patternModel.patterns) { | ||
73 | val querySpecification = builder.getOrCreateSpecification(pattern) | ||
74 | res.put(querySpecification.fullyQualifiedName,querySpecification) | ||
75 | //println('''«querySpecification.fullyQualifiedName» -> «querySpecification»''') | ||
76 | } | ||
77 | resource.validate | ||
78 | return res | ||
79 | } | ||
80 | |||
81 | def private validate(Resource resource) { | ||
82 | val errors = resource.errors | ||
83 | if(!errors.isEmpty) { | ||
84 | println('''-- Errors --''') | ||
85 | errors.forEach[println('''> «it»''')] | ||
86 | println('''------------''') | ||
87 | } | ||
88 | } | ||
89 | } \ No newline at end of file | ||