1 files changed, 80 insertions, 0 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java
new file mode 100644
index 00000000..0d7d6c5c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java
@@ -0,0 +1,80 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.tuple.Tuple;
+
+public class DefaultStorageRefiner<T> implements StorageRefiner {
+        private static final StorageRefiner.Factory<Object> FACTORY = (symbol, model) -> {
+                var interpretation = model.getInterpretation(symbol);
+                return new DefaultStorageRefiner<>(interpretation);
+        };
+
+        private final Interpretation<T> interpretation;
+
+        public DefaultStorageRefiner(Interpretation<T> interpretation) {
+                this.interpretation = interpretation;
+        }
+
+        @Override
+        public boolean split(int parentNode, int childNode) {
+                var symbol = interpretation.getSymbol();
+                int arity = symbol.arity();
+                for (int i = 0; i < arity; i++) {
+                        int adjacentSize = interpretation.getAdjacentSize(i, parentNode);
+                        if (adjacentSize == 0) {
+                                continue;
+                        }
+                        var toSetKeys = new Tuple[adjacentSize];
+                        // This is safe, because we won't pass the array to the outside.
+                        @SuppressWarnings("unchecked")
+                        var toSetValues = (T[]) new Object[adjacentSize];
+                        var cursor = interpretation.getAdjacent(i, parentNode);
+                        int j = 0;
+                        while (cursor.move()) {
+                                toSetKeys[j] = cursor.getKey().set(i, childNode);
+                                toSetValues[j] = cursor.getValue();
+                                j++;
+                        }
+                        for (j = 0; j < adjacentSize; j++) {
+                                interpretation.put(toSetKeys[j], toSetValues[j]);
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public boolean cleanup(int nodeToDelete) {
+                var symbol = interpretation.getSymbol();
+                int arity = symbol.arity();
+                var defaultValue = symbol.defaultValue();
+                for (int i = 0; i < arity; i++) {
+                        int adjacentSize = interpretation.getAdjacentSize(i, nodeToDelete);
+                        if (adjacentSize == 0) {
+                                continue;
+                        }
+                        var toDelete = new Tuple[adjacentSize];
+                        var cursor = interpretation.getAdjacent(i, nodeToDelete);
+                        int j = 0;
+                        while (cursor.move()) {
+                                toDelete[j] = cursor.getKey();
+                                j++;
+                        }
+                        for (j = 0; j < adjacentSize; j++) {
+                                interpretation.put(toDelete[j], defaultValue);
+                        }
+                }
+                return true;
+        }
+
+        public static <T> StorageRefiner.Factory<T> factory() {
+                // This is safe, because {@code FACTORY} doesn't depend on {@code T} at all.
+                @SuppressWarnings("unchecked")
+                var typedFactory = (StorageRefiner.Factory<T>) FACTORY;
+                return typedFactory;
+        }
+}