fix: FilteredView default value

The filer can't return true for the default value, because tuples with default
value cannot be enumerated.

10 files changed, 146 insertions, 22 deletions

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 297cdf04..25bcb0dc 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
@@ -572,6 +572,78 @@ class QueryTest {
                 ), predicateResultSet);
         }
 
+        @Test
+        void filteredIntegerViewTest() {
+                var distance = Symbol.of("distance", 2, Integer.class);
+                var nearView = new FilteredView<>(distance, value -> value < 2);
+                var farView = new FilteredView<>(distance, value -> value >= 5);
+                var dangerQuery = Query.of("danger", (builder, a1, a2) -> builder.clause((a3) -> List.of(
+                                a1.notEquivalent(a2),
+                                nearView.call(a1, a3),
+                                nearView.call(a2, a3),
+                                not(farView.call(a1, a2))
+                )));
+                var store = ModelStore.builder()
+                                .symbols(distance)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(dangerQuery))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var distanceInterpretation = model.getInterpretation(distance);
+                distanceInterpretation.put(Tuple.of(0, 1), 1);
+                distanceInterpretation.put(Tuple.of(1, 0), 1);
+                distanceInterpretation.put(Tuple.of(0, 2), 1);
+                distanceInterpretation.put(Tuple.of(2, 0), 1);
+                distanceInterpretation.put(Tuple.of(1, 2), 3);
+                distanceInterpretation.put(Tuple.of(2, 1), 3);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var dangerResultSet = queryEngine.getResultSet(dangerQuery);
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0, 1), false,
+                                Tuple.of(0, 2), false,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), true
+                ), dangerResultSet);
+        }
+
+        @Test
+        void filteredDoubleViewTest() {
+                var distance = Symbol.of("distance", 2, Double.class);
+                var nearView = new FilteredView<>(distance, value -> value < 2);
+                var farView = new FilteredView<>(distance, value -> value >= 5);
+                var dangerQuery = Query.of("danger", (builder, a1, a2) -> builder.clause((a3) -> List.of(
+                                a1.notEquivalent(a2),
+                                nearView.call(a1, a3),
+                                nearView.call(a2, a3),
+                                not(farView.call(a1, a2))
+                )));
+                var store = ModelStore.builder()
+                                .symbols(distance)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(dangerQuery))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var distanceInterpretation = model.getInterpretation(distance);
+                distanceInterpretation.put(Tuple.of(0, 1), 1.0);
+                distanceInterpretation.put(Tuple.of(1, 0), 1.0);
+                distanceInterpretation.put(Tuple.of(0, 2), 1.0);
+                distanceInterpretation.put(Tuple.of(2, 0), 1.0);
+                distanceInterpretation.put(Tuple.of(1, 2), 3.0);
+                distanceInterpretation.put(Tuple.of(2, 1), 3.0);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var dangerResultSet = queryEngine.getResultSet(dangerQuery);
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0, 1), false,
+                                Tuple.of(0, 2), false,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), true
+                ), dangerResultSet);
+        }
+
         @QueryEngineTest
         void assumeTest(QueryEvaluationHint hint) {
                 var age = Symbol.of("age", 1, Integer.class);
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java
index c1f9d688..fd37604e 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java
@@ -20,12 +20,10 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public abstract class AbstractFunctionView<T> extends SymbolView<T> {
-        private final T defaultValue;
         private final List<Parameter> parameters;
 
         protected AbstractFunctionView(Symbol<T> symbol, String name, Parameter outParameter) {
                 super(symbol, name);
-                defaultValue = symbol.defaultValue();
                 parameters = createParameters(symbol.arity(), outParameter);
         }
 
@@ -46,16 +44,16 @@ public abstract class AbstractFunctionView<T> extends SymbolView<T> {
         }
 
         @Override
-        public final boolean filter(Tuple key, T value) {
-                return !Objects.equals(defaultValue, value);
+        protected boolean doFilter(Tuple key, T value) {
+                return true;
         }
 
-        protected Object forwardMapValue(Tuple key, T value) {
+        protected Object forwardMapValue(T value) {
                 return value;
         }
 
-        protected boolean valueEquals(Tuple key, T value, Object otherForwardMappedValue) {
-                return Objects.equals(otherForwardMappedValue, forwardMapValue(key, value));
+        protected boolean valueEquals(T value, Object otherForwardMappedValue) {
+                return Objects.equals(otherForwardMappedValue, forwardMapValue(value));
         }
 
         @Override
@@ -65,7 +63,7 @@ public abstract class AbstractFunctionView<T> extends SymbolView<T> {
                 for (int i = 0; i < size; i++) {
                         result[i] = Tuple.of(key.get(i));
                 }
-                result[key.getSize()] = forwardMapValue(key, value);
+                result[key.getSize()] = forwardMapValue(value);
                 return result;
         }
 
@@ -81,7 +79,7 @@ public abstract class AbstractFunctionView<T> extends SymbolView<T> {
                 Tuple key = Tuple.of(content);
                 var valueInTuple = tuple[tuple.length - 1];
                 T valueInMap = model.getInterpretation(getSymbol()).get(key);
-                return valueEquals(key, valueInMap, valueInTuple);
+                return valueEquals(valueInMap, valueInTuple);
         }
 
         @Override
@@ -95,12 +93,12 @@ public abstract class AbstractFunctionView<T> extends SymbolView<T> {
                 if (o == null || getClass() != o.getClass()) return false;
                 if (!super.equals(o)) return false;
                 AbstractFunctionView<?> that = (AbstractFunctionView<?>) o;
-                return Objects.equals(defaultValue, that.defaultValue) && Objects.equals(parameters, that.parameters);
+                return Objects.equals(parameters, that.parameters);
         }
 
         @Override
         public int hashCode() {
-                return Objects.hash(super.hashCode(), defaultValue, parameters);
+                return Objects.hash(super.hashCode(), parameters);
         }
 
         private static List<Parameter> createParameters(int symbolArity, Parameter outParameter) {
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
index 922c7355..abae6e5c 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
@@ -27,14 +27,16 @@ public class FilteredView<T> extends TuplePreservingView<T> {
 
         public FilteredView(Symbol<T> symbol, String name, Predicate<T> predicate) {
                 this(symbol, name, (k, v) -> predicate.test(v));
+                validateDefaultValue(predicate);
         }
 
         public FilteredView(Symbol<T> symbol, Predicate<T> predicate) {
                 this(symbol, (k, v) -> predicate.test(v));
+                validateDefaultValue(predicate);
         }
 
         @Override
-        public boolean filter(Tuple key, T value) {
+        protected boolean doFilter(Tuple key, T value) {
                 return this.predicate.test(key, value);
         }
 
@@ -51,4 +53,21 @@ public class FilteredView<T> extends TuplePreservingView<T> {
         public int hashCode() {
                 return Objects.hash(super.hashCode(), predicate);
         }
+
+        private void validateDefaultValue(Predicate<T> predicate) {
+                var defaultValue = getSymbol().defaultValue();
+                boolean matchesDefaultValue = false;
+                try {
+                        matchesDefaultValue = predicate.test(defaultValue);
+                } catch (NullPointerException e) {
+                        if (defaultValue != null) {
+                                throw e;
+                        }
+                        // The predicate doesn't need to handle the default value if it is null.
+                }
+                if (matchesDefaultValue) {
+                        throw new IllegalArgumentException("Tuples with default value %s cannot be enumerated in %s"
+                                        .formatted(defaultValue, getSymbol()));
+                }
+        }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java
index 26b717ee..c312330e 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java
@@ -15,7 +15,7 @@ public class ForbiddenView extends TuplePreservingView<TruthValue> {
         }
 
         @Override
-        public boolean filter(Tuple key, TruthValue value) {
+        protected boolean doFilter(Tuple key, TruthValue value) {
                 return !value.may();
         }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java
index 7e86f6e4..f0e4a61e 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java
@@ -21,8 +21,8 @@ public final class KeyOnlyView<T> extends TuplePreservingView<T> {
         }
 
         @Override
-        public boolean filter(Tuple key, T value) {
-                return !Objects.equals(value, defaultValue);
+        protected boolean doFilter(Tuple key, T value) {
+                return true;
         }
 
         @Override
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java
index e75a8171..c322e220 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java
@@ -15,7 +15,7 @@ public class MayView extends TuplePreservingView<TruthValue> {
         }
 
         @Override
-        public boolean filter(Tuple key, TruthValue value) {
+        protected boolean doFilter(Tuple key, TruthValue value) {
                 return value.may();
         }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java
index a48f8045..65bb4e4c 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java
@@ -15,7 +15,7 @@ public class MustView extends TuplePreservingView<TruthValue> {
         }
 
         @Override
-        public boolean filter(Tuple key, TruthValue value) {
+        protected boolean doFilter(Tuple key, TruthValue value) {
                 return value.must();
         }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java
index 267a99d3..cd8bd56b 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java
@@ -21,7 +21,6 @@ import java.util.UUID;
  */
 public abstract non-sealed class SymbolView<T> implements AnySymbolView {
         private final Symbol<T> symbol;
-
         private final String viewName;
 
         protected SymbolView(Symbol<T> symbol, String viewName) {
@@ -48,7 +47,11 @@ public abstract non-sealed class SymbolView<T> implements AnySymbolView {
                 return symbol.name() + "#" + viewName;
         }
 
-        public abstract boolean filter(Tuple key, T value);
+        public final boolean filter(Tuple key, T value) {
+                return !Objects.equals(symbol.defaultValue(), value) && doFilter(key, value);
+        }
+
+        protected abstract boolean doFilter(Tuple key, T value);
 
         public abstract Object[] forwardMap(Tuple key, T value);
 
@@ -77,6 +80,6 @@ public abstract non-sealed class SymbolView<T> implements AnySymbolView {
 
         @Override
         public int hashCode() {
-                return Objects.hash(symbol, viewName);
+                return Objects.hash(getClass(), symbol, viewName);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java
index ce2d6ff3..40de4644 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java
@@ -9,6 +9,8 @@ import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.query.view.TuplePreservingView;
 import tools.refinery.store.tuple.Tuple;
 
+import java.util.Objects;
+
 class InferredMayTypeView extends TuplePreservingView<InferredType> {
         private final PartialRelation type;
 
@@ -18,7 +20,21 @@ class InferredMayTypeView extends TuplePreservingView<InferredType> {
         }
 
         @Override
-        public boolean filter(Tuple key, InferredType value) {
+        protected boolean doFilter(Tuple key, InferredType value) {
                 return value.mayConcreteTypes().contains(type);
         }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                if (!super.equals(o)) return false;
+                InferredMayTypeView that = (InferredMayTypeView) o;
+                return Objects.equals(type, that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), type);
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java
index beda1796..1a121547 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java
@@ -9,6 +9,8 @@ import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.query.view.TuplePreservingView;
 import tools.refinery.store.tuple.Tuple;
 
+import java.util.Objects;
+
 class InferredMustTypeView extends TuplePreservingView<InferredType> {
         private final PartialRelation type;
 
@@ -18,7 +20,21 @@ class InferredMustTypeView extends TuplePreservingView<InferredType> {
         }
 
         @Override
-        public boolean filter(Tuple key, InferredType value) {
+        protected boolean doFilter(Tuple key, InferredType value) {
                 return value.mustTypes().contains(type);
         }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                if (!super.equals(o)) return false;
+                InferredMustTypeView that = (InferredMustTypeView) o;
+                return Objects.equals(type, that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), type);
+        }
 }