From ffb4c903f350920cbba0fe5ffa059056246adc27 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sun, 19 Sep 2021 18:02:42 +0200 Subject: Small fixes over the project --- .../solver/language/tests/ProblemParsingTest.xtend | 11 +- .../viatra/solver/data/query/RelationalQuery.java | 208 --------------------- .../data/query/internal/PredicateTranslator.java | 208 +++++++++++++++++++++ .../data/query/view/KeyOnlyRelationView.java | 4 +- 4 files changed, 216 insertions(+), 215 deletions(-) delete mode 100644 model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java create mode 100644 model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/PredicateTranslator.java diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend index fcf05d1d..11bfc6d9 100644 --- a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend +++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend @@ -42,13 +42,14 @@ class ProblemParsingTest { } % A child cannot have any dependents. - error invalidTaxStatus(Person p) <=> + error invalidTaxStatus(Person p) <-> taxStatus(p, child), children(p, _q). - Family('family'). - members('family', anne): true. - members('family', bob). - members('family', ciri). + unique family. + Family(family). + members(family, anne): true. + members(family, bob). + members(family, ciri). children(anne, ciri). ?children(bob, ciri). taxStatus(anne, adult). diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java deleted file mode 100644 index 39fc2482..00000000 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java +++ /dev/null @@ -1,208 +0,0 @@ -package org.eclipse.viatra.solver.data.query; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.LinkedHashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher; -import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification; -import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine; -import org.eclipse.viatra.query.runtime.api.scope.QueryScope; -import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint; -import org.eclipse.viatra.query.runtime.matchers.psystem.PBody; -import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryReflexiveTransitiveClosure; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall; -import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint; -import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery; -import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter; -import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery; -import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility; -import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples; -import org.eclipse.viatra.solver.data.query.view.RelationView; - -public class RelationalQuery extends BasePQuery { - - private final Map parameters = new HashMap(); - private String fullyQualifiedName; - private LinkedList bodies = new LinkedList(); - private List symbolicParameters; - - public RelationalQuery(String fullyQualifiedName) { - super(PVisibility.PUBLIC); - this.fullyQualifiedName = fullyQualifiedName; - PBody body = new PBody(this); - bodies.add(body); - } - - @Override - public String getFullyQualifiedName() { - return fullyQualifiedName; - } - - public RelationalQuery addParameter(String name, RelationView type) { - PParameter parameter = new PParameter(name); - parameters.put(name, parameter); - - PBody body = bodies.peekLast(); - List symbolicParameters = new ArrayList<>(); - parameters.forEach((pName, pParameter) -> { - PVariable var = body.getOrCreateVariableByName(pName); - symbolicParameters.add(new ExportedParameter(body, var, pParameter)); - }); - body.setSymbolicParameters(symbolicParameters); - - return this; - } - - @Override - public List getParameters() { - return new ArrayList(parameters.values()); - } - public RelationalQuery addConstraint(RelationView view, String... name) { - if(name.length != view.getArity()) { - throw new IllegalArgumentException("Arity ("+view.getArity()+") does not match parameter numbers ("+name.length+")"); - } - PBody body = bodies.peekLast(); - Object[] variables = new Object[name.length]; - for(int i = 0; i symbolicParameters = new ArrayList<>(); - parameters.forEach((name, parameter) -> { - PVariable var = body.getOrCreateVariableByName(name); - symbolicParameters.add(new ExportedParameter(body, var, parameter)); - }); - body.setSymbolicParameters(symbolicParameters); - bodies.add(body); - return this; - } - - // Equality constraint - public RelationalQuery addEquality(String sourceName, String targetName) { - PBody body = bodies.peekLast(); - PVariable var_source = body.getOrCreateVariableByName(sourceName); - PVariable var_target = body.getOrCreateVariableByName(targetName); - new Equality(body, var_source, var_target); - return this; - } - - // Inequality constraint - public RelationalQuery addInequality(String sourceName, String targetName) { - PBody body = bodies.peekLast(); - PVariable var_source = body.getOrCreateVariableByName(sourceName); - PVariable var_target = body.getOrCreateVariableByName(targetName); - new Inequality(body, var_source, var_target); - return this; - } - - // Positive pattern call - public RelationalQuery addPatternCall(PQuery query, String... names) { - PBody body = bodies.peekLast(); - PVariable[] vars = new PVariable[names.length]; - for (int i = 0; i < names.length; i++) { - vars[i] = body.getOrCreateVariableByName(names[i]); - } - new PositivePatternCall(body, Tuples.flatTupleOf(vars), query); - return this; - } - - // Negative pattern call - public RelationalQuery addNegativePatternCall(PQuery query, String... names) { - PBody body = bodies.peekLast(); - PVariable[] vars = new PVariable[names.length]; - for (int i = 0; i < names.length; i++) { - vars[i] = body.getOrCreateVariableByName(names[i]); - } - new NegativePatternCall(body, Tuples.flatTupleOf(vars), query); - return this; - } - - // Binary transitive closure pattern call - public RelationalQuery addBinaryTransitiveClosure(PQuery query, String sourceName, String targetName) { - PBody body = bodies.peekLast(); - PVariable var_source = body.getOrCreateVariableByName(sourceName); - PVariable var_target = body.getOrCreateVariableByName(targetName); - new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_source, var_target), query); - return this; - } - - // Binary reflexive transitive closure pattern call - public RelationalQuery addBinaryReflexiveTransitiveClosure(PQuery query, String sourceName, String targetName) { - PBody body = bodies.peekLast(); - PVariable var_source = body.getOrCreateVariableByName(sourceName); - PVariable var_target = body.getOrCreateVariableByName(targetName); - new BinaryReflexiveTransitiveClosure(body, Tuples.flatTupleOf(var_source, var_target), query, - query.getParameters().get(0).getDeclaredUnaryType()); - return this; - } - - @Override - public Set doGetContainedBodies() { - setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED)); - return new LinkedHashSet(bodies); - } - - public void addSymbolicParameters(ExportedParameter symbolicParameter) { - checkMutability(); - if (symbolicParameters == null) { - symbolicParameters = new ArrayList<>(); - } - symbolicParameters.add(symbolicParameter); - } - - public GenericQuerySpecification build() { - return new GenericQuerySpecification(this) { - - @Override - public Class getPreferredScopeClass() { - return RelationalScope.class; - } - - @Override - protected GenericPatternMatcher instantiate(ViatraQueryEngine engine) { - return defaultInstantiate(engine); - } - - @Override - public GenericPatternMatcher instantiate() { - return new GenericPatternMatcher(this); - } - - }; - } -} \ No newline at end of file diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/PredicateTranslator.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/PredicateTranslator.java new file mode 100644 index 00000000..39fc2482 --- /dev/null +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/PredicateTranslator.java @@ -0,0 +1,208 @@ +package org.eclipse.viatra.solver.data.query; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher; +import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification; +import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine; +import org.eclipse.viatra.query.runtime.api.scope.QueryScope; +import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint; +import org.eclipse.viatra.query.runtime.matchers.psystem.PBody; +import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryReflexiveTransitiveClosure; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall; +import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint; +import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery; +import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter; +import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery; +import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility; +import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples; +import org.eclipse.viatra.solver.data.query.view.RelationView; + +public class RelationalQuery extends BasePQuery { + + private final Map parameters = new HashMap(); + private String fullyQualifiedName; + private LinkedList bodies = new LinkedList(); + private List symbolicParameters; + + public RelationalQuery(String fullyQualifiedName) { + super(PVisibility.PUBLIC); + this.fullyQualifiedName = fullyQualifiedName; + PBody body = new PBody(this); + bodies.add(body); + } + + @Override + public String getFullyQualifiedName() { + return fullyQualifiedName; + } + + public RelationalQuery addParameter(String name, RelationView type) { + PParameter parameter = new PParameter(name); + parameters.put(name, parameter); + + PBody body = bodies.peekLast(); + List symbolicParameters = new ArrayList<>(); + parameters.forEach((pName, pParameter) -> { + PVariable var = body.getOrCreateVariableByName(pName); + symbolicParameters.add(new ExportedParameter(body, var, pParameter)); + }); + body.setSymbolicParameters(symbolicParameters); + + return this; + } + + @Override + public List getParameters() { + return new ArrayList(parameters.values()); + } + public RelationalQuery addConstraint(RelationView view, String... name) { + if(name.length != view.getArity()) { + throw new IllegalArgumentException("Arity ("+view.getArity()+") does not match parameter numbers ("+name.length+")"); + } + PBody body = bodies.peekLast(); + Object[] variables = new Object[name.length]; + for(int i = 0; i symbolicParameters = new ArrayList<>(); + parameters.forEach((name, parameter) -> { + PVariable var = body.getOrCreateVariableByName(name); + symbolicParameters.add(new ExportedParameter(body, var, parameter)); + }); + body.setSymbolicParameters(symbolicParameters); + bodies.add(body); + return this; + } + + // Equality constraint + public RelationalQuery addEquality(String sourceName, String targetName) { + PBody body = bodies.peekLast(); + PVariable var_source = body.getOrCreateVariableByName(sourceName); + PVariable var_target = body.getOrCreateVariableByName(targetName); + new Equality(body, var_source, var_target); + return this; + } + + // Inequality constraint + public RelationalQuery addInequality(String sourceName, String targetName) { + PBody body = bodies.peekLast(); + PVariable var_source = body.getOrCreateVariableByName(sourceName); + PVariable var_target = body.getOrCreateVariableByName(targetName); + new Inequality(body, var_source, var_target); + return this; + } + + // Positive pattern call + public RelationalQuery addPatternCall(PQuery query, String... names) { + PBody body = bodies.peekLast(); + PVariable[] vars = new PVariable[names.length]; + for (int i = 0; i < names.length; i++) { + vars[i] = body.getOrCreateVariableByName(names[i]); + } + new PositivePatternCall(body, Tuples.flatTupleOf(vars), query); + return this; + } + + // Negative pattern call + public RelationalQuery addNegativePatternCall(PQuery query, String... names) { + PBody body = bodies.peekLast(); + PVariable[] vars = new PVariable[names.length]; + for (int i = 0; i < names.length; i++) { + vars[i] = body.getOrCreateVariableByName(names[i]); + } + new NegativePatternCall(body, Tuples.flatTupleOf(vars), query); + return this; + } + + // Binary transitive closure pattern call + public RelationalQuery addBinaryTransitiveClosure(PQuery query, String sourceName, String targetName) { + PBody body = bodies.peekLast(); + PVariable var_source = body.getOrCreateVariableByName(sourceName); + PVariable var_target = body.getOrCreateVariableByName(targetName); + new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_source, var_target), query); + return this; + } + + // Binary reflexive transitive closure pattern call + public RelationalQuery addBinaryReflexiveTransitiveClosure(PQuery query, String sourceName, String targetName) { + PBody body = bodies.peekLast(); + PVariable var_source = body.getOrCreateVariableByName(sourceName); + PVariable var_target = body.getOrCreateVariableByName(targetName); + new BinaryReflexiveTransitiveClosure(body, Tuples.flatTupleOf(var_source, var_target), query, + query.getParameters().get(0).getDeclaredUnaryType()); + return this; + } + + @Override + public Set doGetContainedBodies() { + setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED)); + return new LinkedHashSet(bodies); + } + + public void addSymbolicParameters(ExportedParameter symbolicParameter) { + checkMutability(); + if (symbolicParameters == null) { + symbolicParameters = new ArrayList<>(); + } + symbolicParameters.add(symbolicParameter); + } + + public GenericQuerySpecification build() { + return new GenericQuerySpecification(this) { + + @Override + public Class getPreferredScopeClass() { + return RelationalScope.class; + } + + @Override + protected GenericPatternMatcher instantiate(ViatraQueryEngine engine) { + return defaultInstantiate(engine); + } + + @Override + public GenericPatternMatcher instantiate() { + return new GenericPatternMatcher(this); + } + + }; + } +} \ No newline at end of file diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/KeyOnlyRelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/KeyOnlyRelationView.java index bb1ddaa8..11a24fc8 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/KeyOnlyRelationView.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/KeyOnlyRelationView.java @@ -3,9 +3,9 @@ package org.eclipse.viatra.solver.data.query.view; import org.eclipse.viatra.solver.data.model.Tuple; import org.eclipse.viatra.solver.data.model.representation.Relation; -public class TupleRelationView extends FilteredRelationView{ +public class KeyOnlyRelationView extends FilteredRelationView{ - public TupleRelationView(Relation representation) { + public KeyOnlyRelationView(Relation representation) { super(representation, (k,v)->true); } @Override -- cgit v1.2.3-70-g09d2