aboutsummaryrefslogtreecommitdiffstats
path: root/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
diff options
context:
space:
mode:
Diffstat (limited to 'store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java')
-rw-r--r--store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java189
1 files changed, 0 insertions, 189 deletions
diff --git a/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java b/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
deleted file mode 100644
index bcc03fb4..00000000
--- a/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
+++ /dev/null
@@ -1,189 +0,0 @@
1package tools.refinery.store.query.internal;
2
3import java.util.ArrayList;
4import java.util.HashMap;
5import java.util.InputMismatchException;
6import java.util.LinkedHashSet;
7import java.util.List;
8import java.util.Map;
9import java.util.Set;
10
11import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
12import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
13import org.eclipse.viatra.query.runtime.api.scope.QueryScope;
14import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
15import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
16import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
17import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
18import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
19import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
20import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
21import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
22import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
23import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
24import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery;
25import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
26import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
27import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
28
29import tools.refinery.store.query.building.DNFAnd;
30import tools.refinery.store.query.building.DNFAtom;
31import tools.refinery.store.query.building.DNFPredicate;
32import tools.refinery.store.query.building.EquivalenceAtom;
33import tools.refinery.store.query.building.PredicateAtom;
34import tools.refinery.store.query.building.RelationAtom;
35import tools.refinery.store.query.building.Variable;
36
37public class DNF2PQuery {
38
39 public static SimplePQuery translate(DNFPredicate predicate, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
40 SimplePQuery query = dnf2PQueryMap.get(predicate);
41 if (query != null) {
42 return query;
43 }
44 query = new DNF2PQuery().new SimplePQuery(predicate.getName());
45 Map<Variable, PParameter> parameters = new HashMap<>();
46
47 predicate.getVariables().forEach(variable -> parameters.put(variable, new PParameter(variable.getName())));
48 List<PParameter> parameterList = new ArrayList<>();
49 for(var param : predicate.getVariables()) {
50 parameterList.add(parameters.get(param));
51 }
52 query.setParameter(parameterList);
53 for (DNFAnd clause : predicate.getClauses()) {
54 PBody body = new PBody(query);
55 List<ExportedParameter> symbolicParameters = new ArrayList<>();
56 for(var param : predicate.getVariables()) {
57 PVariable pVar = body.getOrCreateVariableByName(param.getName());
58 symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
59 }
60 body.setSymbolicParameters(symbolicParameters);
61 query.addBody(body);
62 for (DNFAtom constraint : clause.getConstraints()) {
63 translateDNFAtom(constraint, body, dnf2PQueryMap);
64 }
65 }
66 dnf2PQueryMap.put(predicate, query);
67 return query;
68 }
69
70 private static void translateDNFAtom(DNFAtom constraint, PBody body, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
71 if (constraint instanceof EquivalenceAtom equivalence) {
72 translateEquivalenceAtom(equivalence, body);
73 }
74 if (constraint instanceof RelationAtom relation) {
75 translateRelationAtom(relation, body);
76 }
77 if (constraint instanceof PredicateAtom predicate) {
78 translatePredicateAtom(predicate, body, dnf2PQueryMap);
79 }
80 }
81
82 private static void translateEquivalenceAtom(EquivalenceAtom equivalence, PBody body) {
83 PVariable varSource = body.getOrCreateVariableByName(equivalence.getLeft().getName());
84 PVariable varTarget = body.getOrCreateVariableByName(equivalence.getRight().getName());
85 if (equivalence.isPositive())
86 new Equality(body, varSource, varTarget);
87 else
88 new Inequality(body, varSource, varTarget);
89 }
90
91 private static void translateRelationAtom(RelationAtom relation, PBody body) {
92 if (relation.getSubstitution().size() != relation.getView().getArity()) {
93 throw new IllegalArgumentException("Arity (" + relation.getView().getArity()
94 + ") does not match parameter numbers (" + relation.getSubstitution().size() + ")");
95 }
96 Object[] variables = new Object[relation.getSubstitution().size()];
97 for (int i = 0; i < relation.getSubstitution().size(); i++) {
98 variables[i] = body.getOrCreateVariableByName(relation.getSubstitution().get(i).getName());
99 }
100 new TypeConstraint(body, Tuples.flatTupleOf(variables), relation.getView());
101 }
102
103 private static void translatePredicateAtom(PredicateAtom predicate, PBody body, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
104 Object[] variables = new Object[predicate.getSubstitution().size()];
105 for (int i = 0; i < predicate.getSubstitution().size(); i++) {
106 variables[i] = body.getOrCreateVariableByName(predicate.getSubstitution().get(i).getName());
107 }
108 if (predicate.isPositive()) {
109 if (predicate.isTransitive()) {
110 if (predicate.getSubstitution().size() != 2) {
111 throw new IllegalArgumentException("Transitive Predicate Atoms must be binary.");
112 }
113 new BinaryTransitiveClosure(body, Tuples.flatTupleOf(variables),
114 DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
115 } else {
116 new PositivePatternCall(body, Tuples.flatTupleOf(variables),
117 DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
118 }
119 } else {
120 if (predicate.isTransitive()) {
121 throw new InputMismatchException("Transitive Predicate Atoms cannot be negative.");
122 } else {
123 new NegativePatternCall(body, Tuples.flatTupleOf(variables),
124 DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
125 }
126 }
127 }
128
129 public class SimplePQuery extends BasePQuery {
130
131 private String fullyQualifiedName;
132 private List<PParameter> parameters;
133 private LinkedHashSet<PBody> bodies = new LinkedHashSet<>();
134
135 public SimplePQuery(String name) {
136 super(PVisibility.PUBLIC);
137 fullyQualifiedName = name;
138 }
139
140 @Override
141 public String getFullyQualifiedName() {
142 return fullyQualifiedName;
143 }
144
145 public void setParameter(List<PParameter> parameters) {
146 this.parameters = parameters;
147 }
148
149 @Override
150 public List<PParameter> getParameters() {
151 return parameters;
152 }
153
154 public void addBody(PBody body) {
155 bodies.add(body);
156 }
157
158 @Override
159 protected Set<PBody> doGetContainedBodies() {
160 setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
161 return bodies;
162 }
163
164 public GenericQuerySpecification<RawPatternMatcher> build() {
165 return new GenericQuerySpecification<RawPatternMatcher>(this) {
166
167 @Override
168 public Class<? extends QueryScope> getPreferredScopeClass() {
169 return RelationalScope.class;
170 }
171
172 @Override
173 protected RawPatternMatcher instantiate(ViatraQueryEngine engine) {
174 RawPatternMatcher matcher = engine.getExistingMatcher(this);
175 if (matcher == null) {
176 matcher = engine.getMatcher(this);
177 }
178 return matcher;
179 }
180
181 @Override
182 public RawPatternMatcher instantiate() {
183 return new RawPatternMatcher(this);
184 }
185
186 };
187 }
188 }
189} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-20 01:24:45 +0000