Merge pull request #38 from nagilooh/design-space-exploration

Comparable transformation rule action

11 files changed, 407 insertions, 0 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
index 5aed5298..ab87ddd5 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.dse;
 
 import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.internal.TransformationRule;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.dse.internal.Activation;
 import tools.refinery.store.dse.internal.DesignSpaceExplorationBuilderImpl;
@@ -65,4 +66,6 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter {
         public void setRandom(long seed);
 
         public List<Version> getSolutions();
+
+        void addTransformationRule(TransformationRule transformationRule);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
index 220f0b2d..1ae09916 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
@@ -13,6 +13,7 @@ import tools.refinery.store.map.Version;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
 import tools.refinery.store.dse.DesignSpaceExplorationStoreAdapter;
@@ -45,6 +46,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         private Map<Version, Version> parents = new HashMap<>();
         private final List<Version> solutions = new ArrayList<>();
         private Map<Version, List<Activation>> statesAndTraversedActivations;
+        @SuppressWarnings("squid:S2245")
         private Random random = new Random();
         private boolean isNewState = false;
         private final boolean isVisualizationEnabled;
@@ -77,6 +79,12 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
 
         }
 
+        @Override
+        public void addTransformationRule(TransformationRule rule) {
+                transformationRules.add(rule);
+                rule.prepare(model, queryEngine);
+        }
+
         public List<Version> getTrajectory() {
                 return new ArrayList<>(trajectory);
         }
@@ -175,6 +183,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         }
 
         @Override
+        @SuppressWarnings("squid:S2245")
         public void setRandom(long seed) {
                 this.random = new Random(seed);
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
index 8123c0d6..37117164 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
@@ -26,10 +26,12 @@ public class TransformationRule {
         private Random random;
         private ModelQueryAdapter queryEngine;
 
+        @SuppressWarnings("squid:S2245")
         public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory) {
                 this(name, precondition, actionFactory, new Random());
         }
 
+        @SuppressWarnings("squid:S2245")
         public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, long seed) {
                 this(name, precondition, actionFactory, new Random(seed));
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java
new file mode 100644
index 00000000..92de565d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.tuple.Tuple;
+
+public interface ActionVariable extends AtomicAction {
+        Tuple getValue();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java
new file mode 100644
index 00000000..6b4c6340
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java
@@ -0,0 +1,54 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class ActivationVariable implements ActionVariable {
+
+        private final int index;
+        private Tuple value;
+
+        public ActivationVariable() {
+                this(0);
+        }
+
+        public ActivationVariable(int index) {
+                this.index = index;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                value = Tuple.of(activation.get(index));
+        }
+
+        @Override
+        public ActivationVariable prepare(Model model) {
+                return this;
+        }
+
+        @Override
+        public Tuple getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (ActivationVariable) other;
+
+                if (index != otherAction.index) {
+                        return false;
+                }
+                if (value == null) {
+                        return otherAction.value == null;
+                }
+                return value.equals(otherAction.value);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
new file mode 100644
index 00000000..a8f10bca
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public interface AtomicAction {
+
+        void fire(Tuple activation);
+
+        AtomicAction prepare(Model model);
+
+        boolean equalsWithSubstitution(AtomicAction other);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
new file mode 100644
index 00000000..9900390f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class DeleteAction implements AtomicAction {
+
+        private final ActionVariable variable;
+        private DesignSpaceExplorationAdapter dseAdapter;
+
+        public DeleteAction(ActionVariable variable) {
+                this.variable = variable;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                dseAdapter.deleteObject(variable.getValue());
+        }
+
+        @Override
+        public DeleteAction prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (DeleteAction) other;
+                return this.variable.getClass() == otherAction.variable.getClass();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
new file mode 100644
index 00000000..90fcc5ac
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple0;
+
+import java.util.Arrays;
+
+public class InsertAction<T> implements AtomicAction {
+
+        private final Interpretation<T> interpretation;
+        private final T value;
+        private final int arity;
+        private final ActionVariable[] variables;
+
+        public InsertAction(Interpretation<T> interpretation, T value, ActionVariable... variables) {
+                this.interpretation = interpretation;
+                this.value = value;
+                this.variables = variables;
+                this.arity = interpretation.getSymbol().arity();
+                if (variables.length != arity) {
+                        throw new IllegalArgumentException("Expected " + arity + " variables, but got " + variables.length);
+                }
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                Tuple tuple;
+                if (arity == 0) {
+                        tuple = Tuple0.INSTANCE;
+                }
+                else if (arity == 1) {
+                        tuple = variables[0].getValue();
+                }
+                else if (arity == 2) {
+                        tuple = Tuple.of(variables[0].getValue().get(0), variables[1].getValue().get(0));
+                }
+                else if (arity == 3) {
+                        tuple = Tuple.of(variables[0].getValue().get(0), variables[1].getValue().get(0), variables[2].getValue().get(0));
+                }
+                else {
+                        tuple = Tuple.of(Arrays.stream(variables).map(variable -> variable.getValue().get(0))
+                                        .mapToInt(Integer::intValue).toArray());
+                }
+                interpretation.put(tuple, value);
+        }
+
+        public void put(Tuple tuple) {
+                interpretation.put(tuple, value);
+        }
+
+        @Override
+        public InsertAction<T> prepare(Model model) {
+                return this;
+        }
+
+        public ActionVariable[] getVariables() {
+                return variables;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (InsertAction<?>) other;
+                if (variables.length != otherAction.variables.length) {
+                        return false;
+                }
+                if (!interpretation.equals(otherAction.interpretation)) {
+                        return false;
+                }
+                if (value == null) {
+                        if (otherAction.value != null) {
+                                return false;
+                        }
+                }
+        else if (!value.equals(otherAction.value)) {
+                        return false;
+                }
+                for (var i = 0; i < variables.length; i++) {
+                        if (!variables[i].equalsWithSubstitution(otherAction.variables[i])) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java
new file mode 100644
index 00000000..cbb9697e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+public class NewItemVariable implements ActionVariable {
+        private DesignSpaceExplorationAdapter dseAdapter;
+        private Tuple1 value;
+
+        @Override
+        public void fire(Tuple activation) {
+                value = dseAdapter.createObject();
+        }
+
+        @Override
+        public NewItemVariable prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+
+        @Override
+        public Tuple1 getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (NewItemVariable) other;
+                if (value == null) {
+                        return otherAction.value == null;
+                }
+                return value.equals(otherAction.value);
+
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
new file mode 100644
index 00000000..adc4df9e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple2;
+
+import java.util.*;
+
+public class TransformationAction {
+        private final List<ActionVariable> actionVariables = new ArrayList<>();
+        private final List<InsertAction<?>> insertActions = new ArrayList<>();
+        private final List<DeleteAction> deleteActions = new ArrayList<>();
+        private boolean configured = false;
+        private final Map<Integer, List<Tuple2>> actionVariableUsageMap = new LinkedHashMap<>();
+
+        public TransformationAction add(ActionVariable action) {
+                checkConfigured();
+                actionVariables.add(action);
+                return this;
+        }
+
+        public TransformationAction add(InsertAction<?> action) {
+                checkConfigured();
+                insertActions.add(action);
+                return this;
+        }
+
+        public TransformationAction add(DeleteAction action) {
+                checkConfigured();
+                deleteActions.add(action);
+                return this;
+        }
+
+        private void checkConfigured() {
+                if (configured) {
+                        throw new IllegalStateException("Action already configured.");
+                }
+        }
+
+        public TransformationAction prepare(Model model) {
+                for (ActionVariable action : actionVariables) {
+                        action.prepare(model);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.prepare(model);
+                }
+                for (DeleteAction action : deleteActions) {
+                        action.prepare(model);
+                }
+
+                for (var insertAction : insertActions) {
+                        var actionIndex = insertActions.indexOf(insertAction);
+                        var variables = insertAction.getVariables();
+                        for (var i = 0; i < variables.length; i++) {
+                                var variablelGlobalIndex = actionVariables.indexOf(variables[i]);
+                                actionVariableUsageMap.computeIfAbsent(variablelGlobalIndex, k -> new ArrayList<>());
+                                actionVariableUsageMap.get(variablelGlobalIndex).add(Tuple.of(actionIndex, i));
+                        }
+                }
+
+                configured = true;
+                return this;
+        }
+
+        public boolean fire(Tuple activation) {
+                for (ActionVariable action : actionVariables) {
+                        action.fire(activation);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.fire(activation);
+                }
+                for (DeleteAction action : deleteActions) {
+                        action.fire(activation);
+                }
+                return true;
+        }
+
+        // Returns true if ActionVariables and InsertActions are inserted in same order, ActionVariables are equal (they
+        // have the same index for getting the value from the activation Tuple) and InsertActions are equal (they have
+        // the same arity and value to be set).
+        public boolean equalsWithSubstitution(TransformationAction other) {
+                if (other == this) {
+                        return true;
+                }
+
+                if (actionVariables.size() != other.actionVariables.size()) {
+                        return false;
+                }
+
+                if (insertActions.size() != other.insertActions.size()) {
+                        return false;
+                }
+
+                if (deleteActions.size() != other.deleteActions.size()) {
+                        return false;
+                }
+
+                for (var i = 0; i < actionVariables.size(); i++) {
+                        var variable = actionVariables.get(i);
+                        var otherVariable = other.actionVariables.get(i);
+                        if (!variable.equalsWithSubstitution(otherVariable)) {
+                                return false;
+                        }
+                }
+
+                for (var i = 0; i < insertActions.size(); i++) {
+                        var insertAction = insertActions.get(i);
+                        var otherInsertAction = other.insertActions.get(i);
+                        if (!insertAction.equalsWithSubstitution(otherInsertAction)) {
+                                return false;
+                        }
+                }
+
+                for (var i = 0; i < deleteActions.size(); i++) {
+                        var deleteAction = deleteActions.get(i);
+                        var otherDeleteAction = other.deleteActions.get(i);
+                        if (!deleteAction.equalsWithSubstitution(otherDeleteAction)) {
+                                return false;
+                        }
+                }
+                return this.actionVariableUsageMap.equals(other.actionVariableUsageMap);
+
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
index 327d5e2f..cdd1754f 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
@@ -22,6 +22,7 @@ import java.util.Random;
 public class AlwaysSatisfiedRandomHardObjective extends BaseObjective {
 
         private static final String DEFAULT_NAME = "AlwaysSatisfiedDummyHardObjective";
+        @SuppressWarnings("squid:S2245")
         private static final Random random = new Random(0);
 
         public AlwaysSatisfiedRandomHardObjective() {