refactor: query equality and hash code

Allow computing hash codes up to the renaming of variables.

Also introduces CheckLiteral instead of AssumeLiteral for more straightforward
naming.

4 files changed, 17 insertions, 17 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/AssumptionEvaluator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CheckEvaluator.java
index cf127291..5dde41be 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/AssumptionEvaluator.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CheckEvaluator.java
@@ -8,8 +8,8 @@ package tools.refinery.store.query.viatra.internal.pquery;
 import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
 import tools.refinery.store.query.term.Term;
 
-class AssumptionEvaluator extends TermEvaluator<Boolean> {
-        public AssumptionEvaluator(Term<Boolean> term) {
+class CheckEvaluator extends TermEvaluator<Boolean> {
+        public CheckEvaluator(Term<Boolean> term) {
                 super(term);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
index 5b0ea61d..38fd017e 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
@@ -141,8 +141,8 @@ public class Dnf2PQuery {
                         translateConstantLiteral(constantLiteral, body);
                 } else if (literal instanceof AssignLiteral<?> assignLiteral) {
                         translateAssignLiteral(assignLiteral, body);
-                } else if (literal instanceof AssumeLiteral assumeLiteral) {
-                        translateAssumeLiteral(assumeLiteral, body);
+                } else if (literal instanceof CheckLiteral checkLiteral) {
+                        translateCheckLiteral(checkLiteral, body);
                 } else if (literal instanceof CountLiteral countLiteral) {
                         translateCountLiteral(countLiteral, body);
                 } else if (literal instanceof AggregationLiteral<?, ?> aggregationLiteral) {
@@ -153,9 +153,9 @@ public class Dnf2PQuery {
         }
 
         private void translateEquivalenceLiteral(EquivalenceLiteral equivalenceLiteral, PBody body) {
-                PVariable varSource = body.getOrCreateVariableByName(equivalenceLiteral.left().getUniqueName());
-                PVariable varTarget = body.getOrCreateVariableByName(equivalenceLiteral.right().getUniqueName());
-                if (equivalenceLiteral.positive()) {
+                PVariable varSource = body.getOrCreateVariableByName(equivalenceLiteral.getLeft().getUniqueName());
+                PVariable varTarget = body.getOrCreateVariableByName(equivalenceLiteral.getRight().getUniqueName());
+                if (equivalenceLiteral.isPositive()) {
                         new Equality(body, varSource, varTarget);
                 } else {
                         new Inequality(body, varSource, varTarget);
@@ -212,13 +212,13 @@ public class Dnf2PQuery {
         }
 
         private void translateConstantLiteral(ConstantLiteral constantLiteral, PBody body) {
-                var variable = body.getOrCreateVariableByName(constantLiteral.variable().getUniqueName());
-                new ConstantValue(body, variable, constantLiteral.nodeId());
+                var variable = body.getOrCreateVariableByName(constantLiteral.getVariable().getUniqueName());
+                new ConstantValue(body, variable, constantLiteral.getNodeId());
         }
 
         private <T> void translateAssignLiteral(AssignLiteral<T> assignLiteral, PBody body) {
-                var variable = body.getOrCreateVariableByName(assignLiteral.variable().getUniqueName());
-                var term = assignLiteral.term();
+                var variable = body.getOrCreateVariableByName(assignLiteral.getVariable().getUniqueName());
+                var term = assignLiteral.getTerm();
                 if (term instanceof ConstantTerm<T> constantTerm) {
                         new ConstantValue(body, variable, constantTerm.getValue());
                 } else {
@@ -227,8 +227,8 @@ public class Dnf2PQuery {
                 }
         }
 
-        private void translateAssumeLiteral(AssumeLiteral assumeLiteral, PBody body) {
-                var evaluator = new AssumptionEvaluator(assumeLiteral.term());
+        private void translateCheckLiteral(CheckLiteral checkLiteral, PBody body) {
+                var evaluator = new CheckEvaluator(checkLiteral.getTerm());
                 new ExpressionEvaluation(body, evaluator, null);
         }
 
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
index 258127e7..c4f877c5 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
@@ -29,7 +29,7 @@ import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static tools.refinery.store.query.literal.Literals.assume;
+import static tools.refinery.store.query.literal.Literals.check;
 import static tools.refinery.store.query.term.int_.IntTerms.*;
 import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertNullableResults;
 import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
@@ -390,7 +390,7 @@ class FunctionalQueryTest {
                 var query = Query.of("InvalidAssume", (builder, p1) -> builder.clause(Integer.class, (x) -> List.of(
                                 personView.call(p1),
                                 ageView.call(p1, x),
-                                assume(lessEq(div(constant(120), x), constant(5)))
+                                check(lessEq(div(constant(120), x), constant(5)))
                 )));
 
                 var store = ModelStore.builder()
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index 25bcb0dc..be05b5e6 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -23,7 +23,7 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.List;
 import java.util.Map;
 
-import static tools.refinery.store.query.literal.Literals.assume;
+import static tools.refinery.store.query.literal.Literals.check;
 import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.query.term.int_.IntTerms.constant;
 import static tools.refinery.store.query.term.int_.IntTerms.greaterEq;
@@ -652,7 +652,7 @@ class QueryTest {
                 var query = Query.of("Constraint", (builder, p1) -> builder.clause(Integer.class, (x) -> List.of(
                                 personView.call(p1),
                                 ageView.call(p1, x),
-                                assume(greaterEq(x, constant(18)))
+                                check(greaterEq(x, constant(18)))
                 )));
 
                 var store = ModelStore.builder()