feat(store): DataRepresentation reflective type

7 files changed, 72 insertions, 60 deletions

diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
index 0378983c..233cc156 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
@@ -39,7 +39,8 @@ public class ModelInitializer {
                         var isEqualsRelation = relation == builtinSymbols.equals();
                         var decisionTree = mergeAssertions(relationInfo, isEqualsRelation);
                         var defaultValue = isEqualsRelation ? TruthValue.FALSE : TruthValue.UNKNOWN;
-                        relationTrace.put(relation, new Relation<>(relationInfo.name(), relationInfo.arity(), defaultValue));
+                        relationTrace.put(relation, new Relation<>(relationInfo.name(), relationInfo.arity(), TruthValue.class, defaultValue
+                        ));
                 }
         }
 
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
index ea92b223..a7e09023 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
@@ -20,8 +20,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 class QueryTest {
         @Test
         void typeConstraintTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Boolean> asset = new Relation<>("Asset", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Boolean> asset = new Relation<>("Asset", 1, Boolean.class, false);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
                 var p1 = new Variable("p1");
@@ -46,8 +46,8 @@ class QueryTest {
 
         @Test
         void relationConstraintTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -85,8 +85,8 @@ class QueryTest {
 
         @Test
         void andTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -133,8 +133,8 @@ class QueryTest {
 
         @Test
         void existTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -172,9 +172,9 @@ class QueryTest {
 
         @Test
         void orTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Boolean> animal = new Relation<>("Animal", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Boolean> animal = new Relation<>("Animal", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<Boolean> animalView = new KeyOnlyRelationView(animal);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
@@ -216,7 +216,7 @@ class QueryTest {
 
         @Test
         void equalityTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
                 Variable p1 = new Variable("p1");
@@ -244,8 +244,8 @@ class QueryTest {
 
         @Test
         void inequalityTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -281,8 +281,8 @@ class QueryTest {
 
         @Test
         void patternCallTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -327,8 +327,8 @@ class QueryTest {
 
         @Test
         void negativePatternCallTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -372,8 +372,8 @@ class QueryTest {
 
         @Test
         void negativeWithQuantificationTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -414,8 +414,8 @@ class QueryTest {
 
         @Test
         void transitivePatternCallTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
@@ -458,8 +458,8 @@ class QueryTest {
 
         @Test
         void countMatchTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
                                 TruthValue::must);
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
index a555f024..117edd3e 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
@@ -19,8 +19,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 class QueryTransactionTest {
         @Test
         void flushTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Boolean> asset = new Relation<>("Asset", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Boolean> asset = new Relation<>("Asset", 1, Boolean.class, false);
                 RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
                 var p1 = new Variable("p1");
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
index 1a968f50..18c38151 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
@@ -5,8 +5,9 @@ import tools.refinery.store.map.ContinousHashProvider;
 public final class AuxiliaryData<K, V> extends DataRepresentation<K, V> {
         private final ContinousHashProvider<K> hashProvider;
 
-        public AuxiliaryData(String name, ContinousHashProvider<K> hashProvider, V defaultValue) {
-                super(name, defaultValue);
+        public AuxiliaryData(String name, Class<K> keyType, ContinousHashProvider<K> hashProvider, Class<V> valueType,
+                                                 V defaultValue) {
+                super(name, keyType, valueType, defaultValue);
                 this.hashProvider = hashProvider;
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
index 49f74717..61c6291b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
@@ -7,9 +7,15 @@ public abstract sealed class DataRepresentation<K, V> permits Relation, Auxiliar
 
         private final V defaultValue;
 
-        protected DataRepresentation(String name, V defaultValue) {
+        private final Class<K> keyType;
+
+        private final Class<V> valueType;
+
+        protected DataRepresentation(String name, Class<K> keyType, Class<V> valueType, V defaultValue) {
                 this.name = name;
                 this.defaultValue = defaultValue;
+                this.keyType = keyType;
+                this.valueType = valueType;
         }
 
         public String getName() {
@@ -23,4 +29,12 @@ public abstract sealed class DataRepresentation<K, V> permits Relation, Auxiliar
         public V getDefaultValue() {
                 return defaultValue;
         }
+
+        public Class<K> getKeyType() {
+                return keyType;
+        }
+
+        public Class<V> getValueType() {
+                return valueType;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
index 2e21ea37..cc32257c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
@@ -2,14 +2,14 @@ package tools.refinery.store.model.representation;
 
 import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.TupleHashProvider;
+import tools.refinery.store.tuple.Tuple;
 
 public final class Relation<D> extends DataRepresentation<Tuple, D> implements RelationLike {
         private final int arity;
 
-        public Relation(String name, int arity, D defaultValue) {
-                super(name, defaultValue);
+        public Relation(String name, int arity, Class<D> valueType, D defaultValue) {
+                super(name, Tuple.class, valueType, defaultValue);
                 this.arity = arity;
         }
 
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
index 61dd7c74..a9c2e3f7 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
@@ -1,26 +1,22 @@
 package tools.refinery.store.model.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.util.Set;
-
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreImpl;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 class ModelTest {
 
         @Test
         void modelConstructionTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, friend));
                 Model model = store.createModel();
@@ -30,15 +26,15 @@ class ModelTest {
                 assertTrue(model.getDataRepresentations().contains(person));
                 assertTrue(model.getDataRepresentations().contains(friend));
 
-                Relation<Integer> other = new Relation<Integer>("other", 2, null);
+                Relation<Integer> other = new Relation<Integer>("other", 2, Integer.class, null);
                 assertFalse(model.getDataRepresentations().contains(other));
         }
 
         @Test
         void modelBuildingTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
                 Model model = store.createModel();
@@ -56,7 +52,7 @@ class ModelTest {
 
                 assertEquals(3, model.get(age, Tuple.of(0)));
                 assertEquals(1, model.get(age, Tuple.of(1)));
-                assertEquals(null, model.get(age, Tuple.of(2)));
+                assertNull(model.get(age, Tuple.of(2)));
 
                 assertTrue(model.get(friend, Tuple.of(0, 1)));
                 assertFalse(model.get(friend, Tuple.of(0, 5)));
@@ -64,32 +60,32 @@ class ModelTest {
 
         @Test
         void modelBuildingArityFailTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
                 ModelStore store = new ModelStoreImpl(Set.of(person));
                 Model model = store.createModel();
 
                 final Tuple tuple3 = Tuple.of(1, 1, 1);
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true));
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3));
+                assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true));
+                assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3));
         }
 
         @Test
         void modelBuildingNullFailTest() {
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
                 ModelStore store = new ModelStoreImpl(Set.of(age));
                 Model model = store.createModel();
 
                 model.put(age, Tuple.of(1), null); // valid
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1));
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.get(age, null));
+                assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1));
+                assertThrows(IllegalArgumentException.class, () -> model.get(age, null));
 
         }
 
         @Test
         void modelUpdateTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
                 Model model = store.createModel();
@@ -113,8 +109,8 @@ class ModelTest {
 
         @Test
         void restoreTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
-                Relation<Boolean> friend = new Relation<Boolean>("friend", 2, false);
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, Boolean.class, false);
+                Relation<Boolean> friend = new Relation<Boolean>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, friend));
                 Model model = store.createModel();