refactor(langauge-web): use generator facades

6 files changed, 103 insertions, 9 deletions

diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
index 81bf712a..56c7a23b 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
@@ -5,22 +5,31 @@
  */
 package tools.refinery.generator;
 
+import tools.refinery.generator.impl.ProblemTraceImpl;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
-public class AbstractRefinery {
+import java.util.List;
+
+public abstract class AbstractRefinery {
         protected final ProblemTrace problemTrace;
         protected final ModelStore store;
         protected final Model model;
         protected final ReasoningAdapter reasoningAdapter;
 
-        public AbstractRefinery(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+        protected AbstractRefinery(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
                 this.problemTrace = problemTrace;
                 this.store = store;
-                model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                try {
+                        model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                } catch (TranslationException e) {
+                        throw ProblemTraceImpl.wrapException(problemTrace, e);
+                }
                 reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
         }
 
@@ -35,4 +44,11 @@ public class AbstractRefinery {
         public Model getModel() {
                 return model;
         }
+
+        public List<NodeMetadata> getNodesMetadata() {
+                int nodeCount = reasoningAdapter.getNodeCount();
+                return problemTrace.getNodesMetadata(nodeCount, isPreserveNewNodes());
+        }
+
+        protected abstract boolean isPreserveNewNodes();
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
index b60a3890..d4649051 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
@@ -21,6 +21,7 @@ import tools.refinery.language.semantics.model.ModelInitializer;
 import tools.refinery.store.query.ModelQueryBuilder;
 import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.File;
@@ -29,6 +30,8 @@ import java.io.InputStream;
 import java.util.Collection;
 import java.util.Map;
 
+// This class is used as a fluent builder.
+@SuppressWarnings("UnusedReturnValue")
 public abstract class AbstractRefineryBuilder<T> {
         @Inject
         private Provider<XtextResourceSet> resourceSetProvider;
@@ -113,8 +116,12 @@ public abstract class AbstractRefineryBuilder<T> {
                 if (problemLoaded) {
                         throw new IllegalStateException("Problem was already set");
                 }
-                initializer.readProblem(problem);
                 problemTrace.setInitializer(initializer);
+                try {
+                        initializer.readProblem(problem);
+                } catch (TranslationException e) {
+                        throw ProblemTraceImpl.wrapException(problemTrace, e);
+                }
                 problemLoaded = true;
                 return self();
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
index e5115352..78c807d1 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -29,6 +29,11 @@ public class ModelGenerator extends AbstractRefinery {
                 initialVersion = model.commit();
         }
 
+        @Override
+        protected boolean isPreserveNewNodes() {
+                return false;
+        }
+
         public int getRandomSeed() {
                 return randomSeed;
         }
@@ -50,6 +55,8 @@ public class ModelGenerator extends AbstractRefinery {
                                 .toList();
         }
 
+        // This method only makes sense if it returns {@code true} on success.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean tryRun() {
                 var iterator = run(1).iterator();
                 if (!iterator.hasNext()) {
@@ -59,6 +66,12 @@ public class ModelGenerator extends AbstractRefinery {
                 return true;
         }
 
+        public void run() {
+                if (!tryRun()) {
+                        throw new UnsatisfiableProblemException();
+                }
+        }
+
         public <A, C> PartialInterpretation<A, C> getCandidateInterpretation(PartialSymbol<A, C> partialSymbol) {
                 return reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, partialSymbol);
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
index 8bac1910..661bc97c 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
@@ -19,6 +19,11 @@ public class ModelSemantics extends AbstractRefinery {
                 super(problemTrace, store, modelSeed);
         }
 
+        @Override
+        protected boolean isPreserveNewNodes() {
+                return true;
+        }
+
         public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
                 return reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL, partialSymbol);
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
index 7be2dc00..f7963c58 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
@@ -8,8 +8,12 @@ package tools.refinery.generator;
 import org.eclipse.xtext.naming.QualifiedName;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
+import tools.refinery.language.semantics.metadata.RelationMetadata;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
+import java.util.List;
 import java.util.Map;
 
 public interface ProblemTrace {
@@ -17,9 +21,15 @@ public interface ProblemTrace {
 
         Map<Relation, PartialRelation> getRelationTrace();
 
+        Relation getInverseTrace(AnyPartialSymbol partialSymbol);
+
         PartialRelation getPartialRelation(Relation relation);
 
         PartialRelation getPartialRelation(QualifiedName qualifiedName);
 
         PartialRelation getPartialRelation(String qualifiedName);
+
+        List<RelationMetadata> getRelationsMetadata();
+
+        List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes);
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java b/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
index 109e34af..5671d3f8 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
@@ -6,6 +6,7 @@
 package tools.refinery.generator.impl;
 
 import com.google.inject.Inject;
+import com.google.inject.Provider;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
@@ -15,10 +16,17 @@ import tools.refinery.generator.ProblemTrace;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.ProblemPackage;
 import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.metadata.MetadataCreator;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
+import tools.refinery.language.semantics.metadata.RelationMetadata;
 import tools.refinery.language.semantics.model.ModelInitializer;
+import tools.refinery.language.semantics.model.TracedException;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 public final class ProblemTraceImpl implements ProblemTrace {
@@ -31,22 +39,31 @@ public final class ProblemTraceImpl implements ProblemTrace {
         @Inject
         private IScopeProvider scopeProvider;
 
-        private Problem problem;
+        @Inject
+        private Provider<MetadataCreator> metadataCreatorProvider;
+
+        private ModelInitializer initializer;
         private Map<Relation, PartialRelation> relationTrace;
+        private MetadataCreator metadataCreator;
 
         public void setInitializer(ModelInitializer initializer) {
-                problem = initializer.getProblem();
+                this.initializer = initializer;
                 relationTrace = Collections.unmodifiableMap(initializer.getRelationTrace());
         }
 
         public Problem getProblem() {
-                return problem;
+                return initializer.getProblem();
         }
 
         public Map<Relation, PartialRelation> getRelationTrace() {
                 return relationTrace;
         }
 
+        @Override
+        public Relation getInverseTrace(AnyPartialSymbol partialSymbol) {
+                return initializer.getInverseTrace(partialSymbol);
+        }
+
         public PartialRelation getPartialRelation(Relation relation) {
                 var partialRelation = relationTrace.get(relation);
                 if (partialRelation == null) {
@@ -58,7 +75,7 @@ public final class ProblemTraceImpl implements ProblemTrace {
         }
 
         public PartialRelation getPartialRelation(QualifiedName qualifiedName) {
-                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                var scope = scopeProvider.getScope(getProblem(), ProblemPackage.Literals.ASSERTION__RELATION);
                 var iterator = scope.getElements(qualifiedName).iterator();
                 if (!iterator.hasNext()) {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
@@ -69,7 +86,7 @@ public final class ProblemTraceImpl implements ProblemTrace {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
                         throw new IllegalArgumentException("Ambiguous relation: " + qualifiedNameString);
                 }
-                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), problem);
+                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), getProblem());
                 if (!(eObject instanceof Relation relation)) {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
                         throw new IllegalArgumentException("Not a relation: " + qualifiedNameString);
@@ -81,4 +98,30 @@ public final class ProblemTraceImpl implements ProblemTrace {
                 var convertedName = qualifiedNameConverter.toQualifiedName(qualifiedName);
                 return getPartialRelation(convertedName);
         }
+
+        @Override
+        public List<RelationMetadata> getRelationsMetadata() {
+                return getMetadataCreator().getRelationsMetadata();
+        }
+
+        @Override
+        public List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes) {
+                return getMetadataCreator().getNodesMetadata(nodeCount, preserveNewNodes);
+        }
+
+        private MetadataCreator getMetadataCreator() {
+                if (metadataCreator == null) {
+                        metadataCreator = metadataCreatorProvider.get();
+                        metadataCreator.setInitializer(initializer);
+                }
+                return metadataCreator;
+        }
+
+        public static RuntimeException wrapException(ProblemTrace trace, TranslationException translationException) {
+                var source = trace.getInverseTrace(translationException.getPartialSymbol());
+                if (source == null) {
+                        return translationException;
+                }
+                return new TracedException(source, translationException);
+        }
 }