1 files changed, 71 insertions, 4 deletions

diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
index 5e1ae94d..091b4e04 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
@@ -1,11 +1,11 @@
 package tools.refinery.store.query.literal;
 
-import tools.refinery.store.query.DnfUtils;
 import tools.refinery.store.query.RelationLike;
 import tools.refinery.store.query.Variable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
 
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 
@@ -31,6 +31,8 @@ public abstract class CallLiteral<T extends RelationLike> implements Literal {
                 return polarity;
         }
 
+        public abstract Class<T> getTargetType();
+
         public T getTarget() {
                 return target;
         }
@@ -46,8 +48,44 @@ public abstract class CallLiteral<T extends RelationLike> implements Literal {
                 }
         }
 
-        protected List<Variable> substituteArguments(Map<Variable, Variable> substitution) {
-                return arguments.stream().map(variable -> DnfUtils.maybeSubstitute(variable, substitution)).toList();
+        protected List<Variable> substituteArguments(Substitution substitution) {
+                return arguments.stream().map(substitution::getSubstitute).toList();
+        }
+
+        /**
+         * Compares the target of this call literal with another object.
+         *
+         * @param helper      Equality helper for comparing {@link Variable} and {@link tools.refinery.store.query.Dnf}
+         *                    instances.
+         * @param otherTarget The object to compare the target to.
+         * @return {@code true} if {@code otherTarget} is equal to the return value of {@link #getTarget()} according to
+         * {@code helper}, {@code false} otherwise.
+         */
+        protected boolean targetEquals(LiteralEqualityHelper helper, T otherTarget) {
+                return target.equals(otherTarget);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other.getClass() != getClass()) {
+                        return false;
+                }
+                var otherCallLiteral = (CallLiteral<?>) other;
+                if (getTargetType() != otherCallLiteral.getTargetType() || polarity != otherCallLiteral.polarity) {
+                        return false;
+                }
+                var arity = arguments.size();
+                if (arity != otherCallLiteral.arguments.size()) {
+                        return false;
+                }
+                for (int i = 0; i < arity; i++) {
+                        if (!helper.variableEqual(arguments.get(i), otherCallLiteral.arguments.get(i))) {
+                                return false;
+                        }
+                }
+                @SuppressWarnings("unchecked")
+                var otherTarget = (T) otherCallLiteral.target;
+                return targetEquals(helper, otherTarget);
         }
 
         @Override
@@ -63,4 +101,33 @@ public abstract class CallLiteral<T extends RelationLike> implements Literal {
         public int hashCode() {
                 return Objects.hash(polarity, target, arguments);
         }
+
+        protected String targetToString() {
+                return "@%s %s".formatted(getTargetType().getSimpleName(), target.name());
+        }
+
+        @Override
+        public String toString() {
+                var builder = new StringBuilder();
+                if (!polarity.isPositive()) {
+                        builder.append("!(");
+                }
+                builder.append(targetToString());
+                if (polarity.isTransitive()) {
+                        builder.append("+");
+                }
+                builder.append("(");
+                var argumentIterator = arguments.iterator();
+                if (argumentIterator.hasNext()) {
+                        builder.append(argumentIterator.next());
+                        while (argumentIterator.hasNext()) {
+                                builder.append(", ").append(argumentIterator.next());
+                        }
+                }
+                builder.append(")");
+                if (!polarity.isPositive()) {
+                        builder.append(")");
+                }
+                return builder.toString();
+        }
 }