Create a VariationLabel for representing nested variation trees

Author: ibbem

src/main/java/org/variantsync/diffdetective/editclass/EditClassCatalogue.java

@@ -35,7 +35,7 @@ public interface EditClassCatalogue {
     default EditClass match(DiffNode<?> node)
     {
         if (!node.isArtifact()) {
-            throw new IllegalArgumentException("Expected an artifact node but got " + node.nodeType + "!");
+            throw new IllegalArgumentException("Expected an artifact node but got " + node.getNodeType() + "!");
         }
 
         final List<EditClass> classessToCheck = byType().get(node.diffType);

src/main/java/org/variantsync/diffdetective/editclass/proposed/ProposedEditClasses.java

@@ -75,7 +75,7 @@ public EditClass match(DiffNode<?> node)
         // Each returned value is not null but an actual edit class object.
         // Since the given node may be any node, we have proven that every node is classified by at least one edit class.
         if (!node.isArtifact()) {
-            throw new IllegalArgumentException("Expected an artifact node but got " + node.nodeType + "!");
+            throw new IllegalArgumentException("Expected an artifact node but got " + node.getNodeType() + "!");
         }
 
         if (node.isAdd()) {

src/main/java/org/variantsync/diffdetective/mining/RWCompositePatternNodeFormat.java

@@ -11,11 +11,11 @@ public String toLabel(final DiffNode<? extends DiffLinesLabel> node) {
         if (node.isArtifact()) {
             return ProposedEditClasses.Instance.match(node).getName() + "<br>" + node.getLabel();
         } else {
-            return node.diffType + "_" + switch (node.nodeType) {
+            return node.diffType + "_" + switch (node.getNodeType()) {
                 case IF -> "mapping<br> " + node.getLabel();
                 case ELSE -> "else";
                 case ELIF -> "elif<br>" + node.getLabel();
-                default -> node.nodeType + "<br>" + node.getLabel();
+                default -> node.getNodeType() + "<br>" + node.getLabel();
             };
         }
     }

src/main/java/org/variantsync/diffdetective/mining/formats/DebugMiningDiffNodeFormat.java

@@ -20,7 +20,7 @@ public String toLabel(final DiffNode<? extends DiffLinesLabel> node) {
         if (node.isArtifact()) {
             return ProposedEditClasses.Instance.match(node).getName();
         } else {
-            return node.diffType + "_" + node.nodeType;
+            return node.diffType + "_" + node.getNodeType();
         }
 	}
 

src/main/java/org/variantsync/diffdetective/mining/formats/ReleaseMiningDiffNodeFormat.java

@@ -42,7 +42,7 @@ public String toLabel(DiffNode<? extends DiffLinesLabel> node) {
         if (node.isArtifact()) {
             return ARTIFACT_PREFIX + toId(ProposedEditClasses.Instance.match(node));
         } else {
-            return ANNOTATION_PREFIX + node.diffType.ordinal() + node.nodeType.ordinal();
+            return ANNOTATION_PREFIX + node.diffType.ordinal() + node.getNodeType().ordinal();
         }
     }
 

src/main/java/org/variantsync/diffdetective/variation/VariationLabel.java

@@ -0,0 +1,52 @@
+package org.variantsync.diffdetective.variation;
+
+import java.util.List;
+
+import org.variantsync.diffdetective.variation.tree.HasNodeType;
+import org.variantsync.diffdetective.variation.tree.VariationTree; // For Javadoc
+import org.variantsync.functjonal.Cast;
+
+/**
+ * Extends an inner {@link Label}, the object language, with variability, the meta language.
+ *
+ * This class allows encoding of multiple levels of variability in the sense of variation trees of
+ * variation trees. Such higher-order variation trees can be encoded in a single tree structure
+ * because the result of configuring a variation tree is still a tree. In other words: the object
+ * language of a {@code VariationTree<L>} is a tree with labels {@code L}. The trick is that a
+ * variation tree is just a tree with labels {@code VariationLabel<L>}.
+ *
+ * @param <L> the label of the trees (the object language) over which variability is introduced
+ * @see VariationTree
+ */
+public class VariationLabel<L extends Label> implements Label, HasNodeType {
+    private NodeType type;
+    private L innerLabel;
+
+    public VariationLabel(NodeType type, L innerLabel) {
+        this.type = type;
+        this.innerLabel = innerLabel;
+    }
+
+    public L getInnerLabel() {
+        return innerLabel;
+    }
+
+    public void setInnerLabel(L innerLabel) {
+        this.innerLabel = innerLabel;
+    }
+
+    @Override
+    public List<String> getLines() {
+        return innerLabel.getLines();
+    }
+
+    @Override
+    public NodeType getNodeType() {
+        return type;
+    }
+
+    @Override
+    public VariationLabel<L> clone() {
+        return new VariationLabel<L>(type, Cast.unchecked(innerLabel.clone()));
+    }
+}

src/main/java/org/variantsync/diffdetective/variation/diff/DiffNode.java

@@ -8,6 +8,7 @@
 import org.variantsync.diffdetective.variation.DiffLinesLabel;
 import org.variantsync.diffdetective.variation.Label;
 import org.variantsync.diffdetective.variation.NodeType;
+import org.variantsync.diffdetective.variation.VariationLabel;
 import org.variantsync.diffdetective.variation.tree.HasNodeType;
 import org.variantsync.diffdetective.variation.tree.VariationNode;
 import org.variantsync.functjonal.Cast;
@@ -40,16 +41,15 @@ public class DiffNode<L extends Label> implements HasNodeType {
     public DiffType diffType;
 
     /**
-     * The node type of this node, which determines the type of the represented
-     * element in the diff (e.g., mapping or artifact).
+     * The label together with the node type of this node, which determines the type of the
+     * represented element in the diff (e.g., mapping or artifact).
      */
-    public final NodeType nodeType;
+    public final VariationLabel<L> label;
 
     private DiffLineNumber from = DiffLineNumber.Invalid();
     private DiffLineNumber to = DiffLineNumber.Invalid();
 
     private Node featureMapping;
-    private L label;
 
     /**
      * The parents {@link DiffNode} before and after the edit.
@@ -94,11 +94,10 @@ public DiffNode(DiffType diffType, NodeType nodeType,
         children[AFTER.ordinal()] = new ArrayList<>();
 
         this.diffType = diffType;
-        this.nodeType = nodeType;
+        this.label = new VariationLabel<>(nodeType, label);
         this.from = fromLines;
         this.to = toLines;
         this.featureMapping = featureMapping;
-        this.label = label;
     }
 
     /**
@@ -136,15 +135,15 @@ public static <L extends Label> DiffNode<L> createArtifact(DiffType diffType, Di
      * Returns the lines in the diff that are represented by this DiffNode as a single text.
      */
     public L getLabel() {
-        return label;
+        return label.getInnerLabel();
     }
 
     /**
      * Sets the lines in the diff that are represented by this DiffNode to the given code.
      * Lines are identified by linebreak characters.
      */
-    public void setLabel(L label) {
-        this.label = label;
+    public void setLabel(L newLabel) {
+        label.setInnerLabel(newLabel);
     }
 
     /**
@@ -535,7 +534,7 @@ public DiffType getDiffType() {
 
     @Override
     public NodeType getNodeType() {
-        return nodeType;
+        return label.getNodeType();
     }
 
     /**
@@ -568,13 +567,13 @@ public int getID() {
         id |= diffType.ordinal();
 
         id <<= NodeType.getRequiredBitCount();
-        id |= nodeType.ordinal();
+        id |= getNodeType().ordinal();
         return id;
     }
 
     /**
      * Reconstructs a node from the given id and sets the given label.
-     * An id uniquely determines a node's {@link DiffNode#nodeType}, {@link DiffNode#diffType}, and {@link DiffLineNumber#inDiff line number in the diff}.
+     * An id uniquely determines a node's {@link DiffNode#getNodeType}, {@link DiffNode#diffType}, and {@link DiffLineNumber#inDiff line number in the diff}.
      * The almost-inverse function is {@link DiffNode#getID()} but the conversion is not lossless.
      * @param id The id from which to reconstruct the node.
      * @param label The label the node should have.
@@ -657,7 +656,7 @@ public void assertConsistency() {
         if (this.isIf() || this.isElif()) {
             Assert.assertTrue(this.getFormula() != null, "If or elif without feature mapping!");
         } else {
-            Assert.assertTrue(this.getFormula() == null, "Node with type " + nodeType + " has a non null feature mapping");
+            Assert.assertTrue(this.getFormula() == null, "Node with type " + getNodeType() + " has a non null feature mapping");
         }
     }
 
@@ -692,7 +691,7 @@ public static <T extends VariationNode<T, L>, L extends Label> DiffNode<L> uncha
                 new DiffLineNumber(from, from, from),
                 new DiffLineNumber(to, to, to),
                 variationNode.getFormula(),
-                Cast.unchecked(variationNode.getLabel().clone())
+                variationNode.getLabel()
         );
     }
 
@@ -802,11 +801,11 @@ private static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b,
     public String toString() {
         String s;
         if (isArtifact()) {
-            s = String.format("%s_%s from %d to %d", diffType, nodeType, from.inDiff(), to.inDiff());
+            s = String.format("%s_%s from %d to %d", diffType, getNodeType(), from.inDiff(), to.inDiff());
         } else if (isRoot()) {
             s = "ROOT";
         } else {
-            s = String.format("%s_%s from %d to %d with \"%s\"", diffType, nodeType,
+            s = String.format("%s_%s from %d to %d with \"%s\"", diffType, getNodeType(),
                     from.inDiff(), to.inDiff(), featureMapping);
         }
         return s;

src/main/java/org/variantsync/diffdetective/variation/diff/Projection.java

@@ -54,7 +54,7 @@ public Projection<L> upCast() {
 
     @Override
     public NodeType getNodeType() {
-        return getBackingNode().nodeType;
+        return getBackingNode().getNodeType();
     }
 
     @Override

src/main/java/org/variantsync/diffdetective/variation/diff/serialize/LineGraphImport.java

@@ -144,7 +144,7 @@ private static DiffTree<DiffLinesLabel> parseDiffTree(final String lineGraph, fi
                     if (root != null) {
                         throw new RuntimeException("Not a DiffTree: Got more than one root! Got \"" + root + "\" and \"" + v + "\"!");
                     }
-                    if (v.nodeType == NodeType.IF) {
+                    if (v.getNodeType() == NodeType.IF) {
                         root = v;
                     } else {
                         throw new RuntimeException("Not a DiffTree but a DiffGraph: The node \"" + v + "\" is not labeled as IF but has no parents!");
@@ -156,7 +156,7 @@ private static DiffTree<DiffLinesLabel> parseDiffTree(final String lineGraph, fi
                 throw new RuntimeException("Not a DiffTree but a DiffGraph: No root found!");
             }
 
-//            countRootTypes.merge(root.nodeType, 1, Integer::sum);
+//            countRootTypes.merge(root.getNodeType(), 1, Integer::sum);
 
 			return new DiffTree<>(root, diffTreeSource);
 		} else {

src/main/java/org/variantsync/diffdetective/variation/diff/serialize/nodeformat/DebugDiffNodeFormat.java

@@ -11,7 +11,7 @@
 public class DebugDiffNodeFormat<L extends Label> implements DiffNodeLabelFormat<L> {
 	@Override
 	public String toLabel(final DiffNode<? extends L> node) {
-		return node.diffType + "_" + node.nodeType + "_\"" +
+		return node.diffType + "_" + node.getNodeType() + "_\"" +
 				DiffNodeLabelPrettyfier.prettyPrintIfAnnotationOr(
 						node,
 						FileUtils.replaceLineEndings(node.getLabel().toString().trim().replaceAll("\t", "  "), "<br>"))