1 files changed, 240 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java
new file mode 100644
index 00000000..1998df9d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java
@@ -0,0 +1,240 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.TypeHelper;
+import tools.refinery.viatra.runtime.matchers.planning.operations.POperation;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PProject;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PStart;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+
+/**
+ * A plan representing a subset of (or possibly all the) constraints evaluated. A SubPlan instance is responsible for
+ * representing a state of the plan; but after it is initialized it is expected be immutable 
+ *  (exception: inferred constraints, see {@link #inferConstraint(PConstraint)}).
+ * 
+ * <p> A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans. 
+ * Important maintained information: <ul>
+ * <li>set of <b>variables</b> whose values are known when the runtime evaluation is at this stage,
+ * <li>set of <b>constraints</b> that are known to hold true at this point.
+ * </ul>
+ * 
+ * <p> Recommended to instantiate via a {@link SubPlanFactory} or subclasses, 
+ * so that query planners can subclass SubPlan if needed. 
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class SubPlan {
+    private PBody body;
+    private List<? extends SubPlan> parentPlans;
+    private POperation operation;
+
+    private final Set<PVariable> visibleVariables; 
+    private final Set<PVariable> allVariables; 
+    private final Set<PVariable> introducedVariables; // delta compared to first parent
+    private Set<PConstraint> allConstraints;
+    private Set<PConstraint> deltaConstraints; // delta compared to all parents
+    private Set<PConstraint> externallyInferredConstraints; // inferred in addition to direct consequences of the operation and parents 
+    
+
+    
+    
+    
+    /**
+     * A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans.
+     */
+    public SubPlan(PBody body, POperation operation, SubPlan... parentPlans) {
+        this(body, operation, Arrays.asList(parentPlans));
+    }
+    /**
+     * A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans.
+     */
+    public SubPlan(PBody body, POperation operation, List<? extends SubPlan> parentPlans) {
+        super();
+        this.body = body;
+        this.parentPlans = parentPlans;
+        this.operation = operation;
+        
+        this.externallyInferredConstraints = new HashSet<PConstraint>();
+        this.deltaConstraints = new HashSet<PConstraint>(operation.getDeltaConstraints());
+        
+        this.allVariables = new HashSet<PVariable>();
+        for (PConstraint constraint: deltaConstraints) {
+            this.allVariables.addAll(constraint.getDeducedVariables());
+        }
+        this.allConstraints = new HashSet<PConstraint>(deltaConstraints);
+        for (SubPlan parentPlan: parentPlans) {
+            this.allConstraints.addAll(parentPlan.getAllEnforcedConstraints());
+            this.allVariables.addAll(parentPlan.getAllDeducedVariables());
+        }     
+        
+        // TODO this is ugly a bit
+        if (operation instanceof PStart) {
+            this.visibleVariables = new HashSet<PVariable>(((PStart) operation).getAPrioriVariables());
+            this.allVariables.addAll(visibleVariables);
+        } else if (operation instanceof PProject) { 
+            this.visibleVariables = new HashSet<PVariable>(((PProject) operation).getToVariables());
+        } else {
+            this.visibleVariables = new HashSet<PVariable>();
+            for (SubPlan parentPlan: parentPlans)
+                this.visibleVariables.addAll(parentPlan.getVisibleVariables());
+            for (PConstraint constraint: deltaConstraints)
+                this.visibleVariables.addAll(constraint.getDeducedVariables());
+        } 
+        
+        this.introducedVariables = new HashSet<PVariable>(this.visibleVariables);
+        if (!parentPlans.isEmpty()) 
+            introducedVariables.removeAll(parentPlans.get(0).getVisibleVariables());
+        
+        operation.checkConsistency(this);
+    }
+    
+    
+    @Override
+    public String toString() {
+        return toLongString();
+    }
+    public String toShortString() {
+        return String.format("Plan{%s}:%s", 
+                visibleVariables.stream().map(PVariable::getName).collect(Collectors.joining(",")),
+                operation.getShortName());
+    }
+    public String toLongString() {
+        return String.format("%s<%s>", 
+                toShortString(),
+                parentPlans.stream().map(Object::toString).collect(Collectors.joining("; ")));
+    }
+
+
+    /**
+     * All constraints that are known to hold at this point
+     */
+    public Set<PConstraint> getAllEnforcedConstraints() {
+        return allConstraints;
+    }
+
+    /**
+     * The new constraints enforced at this stage of plan, that aren't yet enforced at parents
+     * (results are also included in {@link SubPlan#getAllEnforcedConstraints()})
+     */
+    public Set<PConstraint> getDeltaEnforcedConstraints() {
+        return deltaConstraints;
+    }
+
+    /**
+     * Indicate that a given constraint was found to be automatically satisfied at this point 
+     *   without additional operations. 
+     * (results are also included in {@link SubPlan#getDeltaEnforcedConstraints()})
+     *   
+     * <p>Warning: not propagated automatically to child plans, 
+     *  so best to invoke before constructing further SubPlans. </p>
+     */
+    public void inferConstraint(PConstraint constraint) {
+        externallyInferredConstraints.add(constraint);
+        deltaConstraints.add(constraint);
+        allConstraints.add(constraint);
+    }
+    
+    public PBody getBody() {
+        return body;
+    }
+    
+    /**
+     * Variables which are assigned a value at this point 
+     * (results are also included in {@link SubPlan#getAllDeducedVariables()})
+     */
+    public Set<PVariable> getVisibleVariables() {
+        return visibleVariables;
+    }
+    /**
+     * Variables which have been assigned a value; 
+     * includes visible variables (see {@link #getVisibleVariables()}) 
+     *   and additionally any variables hidden by a projection (see {@link PProject}). 
+     */
+    public Set<PVariable> getAllDeducedVariables() {
+        return allVariables;
+    }
+    /**
+     * Delta compared to first parent: variables that are visible here but were not visible at the first parent.
+     */
+    public Set<PVariable> getIntroducedVariables() {
+        return introducedVariables;
+    }
+    public List<? extends SubPlan> getParentPlans() {
+        return parentPlans;
+    }
+    public POperation getOperation() {
+        return operation;
+    }
+    
+    
+    /**
+     * The closure of all type judgments of enforced constraints at this point.
+     * <p> No subsumption applied.
+     */
+    public Set<TypeJudgement> getAllImpliedTypeJudgements(IQueryMetaContext context) {
+        Set<TypeJudgement> impliedJudgements = allImpliedTypeJudgements.get(context);
+        if (impliedJudgements == null) {
+            Set<TypeJudgement> equivalentJudgements = TypeHelper.getDirectJudgements(getAllEnforcedConstraints(), context);
+            impliedJudgements = TypeHelper.typeClosure(equivalentJudgements, context);
+
+            allImpliedTypeJudgements.put(context, impliedJudgements);
+        }
+        return impliedJudgements;
+    }
+    private WeakHashMap<IQueryMetaContext, Set<TypeJudgement>> allImpliedTypeJudgements = new WeakHashMap<IQueryMetaContext, Set<TypeJudgement>>();   
+    
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result
+                + ((operation == null) ? 0 : operation.hashCode());
+        result = prime * result
+                + ((parentPlans == null) ? 0 : parentPlans.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof SubPlan))
+            return false;
+        SubPlan other = (SubPlan) obj;
+        if (operation == null) {
+            if (other.operation != null)
+                return false;
+        } else if (!operation.equals(other.operation))
+            return false;
+        if (parentPlans == null) {
+            if (other.parentPlans != null)
+                return false;
+        } else if (!parentPlans.equals(other.parentPlans))
+            return false;
+        return true;
+    }
+
+    
+}