refactor: refactor the time dependent fields in DiffNode

This pattern should be more understandable than the previous array based
implementation. Furthermore, it is now much easier to add new time
dependent fields.

Author: ibbem

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

@@ -13,7 +13,6 @@
 import org.variantsync.diffdetective.variation.tree.VariationNode;
 import org.variantsync.functjonal.Cast;
 
-import java.lang.reflect.Array;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Stream;
@@ -51,32 +50,48 @@ public class DiffNode<L extends Label> implements HasNodeType {
 
     private Node featureMapping;
 
-    /**
-     * The parents {@link DiffNode} before and after the edit.
-     * This array has to be indexed by {@code Time.ordinal()}
-     *
-     * Invariant: Iff {@code getParent(time) != null} then
-     * {@code getParent(time).getChildOrder(time).contains(this)}.
-     */
-    private DiffNode<L>[] parents = Cast.unchecked(Array.newInstance(DiffNode.class, 2));
+    private static class TimeDependentState<L extends Label> {
+        /**
+         * The parents {@link DiffNode} before and after the edit.
+         * This array has to be indexed by {@code Time.ordinal()}
+         *
+         * Invariant: Iff {@code getParent(time) != null} then
+         * {@code getParent(time).getChildOrder(time).contains(this)}.
+         */
+        public DiffNode<L> parent;
+
+        /**
+         * The children before and after the edit.
+         * This array has to be indexed by {@code Time.ordinal()}
+         *
+         * Invariant: Iff {@code getChildOrder(time).contains(child)} then
+         * {@code child.getParent(time) == this}.
+         */
+        public List<DiffNode<L>> children;
+
+        /**
+         * Cache for before and after projections.
+         * It stores the projection node at each time so that only one instance of {@link Projection}
+         * per {@link Time} is ever created. This array has to be indexed by {@code Time.ordinal()}
+         *
+         * <p>This field is required to allow identity tests of {@link Projection}s with {@code ==}.
+         */
+        public Projection<L> projection;
+
+        public TimeDependentState() {
+            parent = null;
+            children = null;
+            children = new ArrayList<>();
+            projection = null;
+        }
+    }
 
-    /**
-     * The children before and after the edit.
-     * This array has to be indexed by {@code Time.ordinal()}
-     *
-     * Invariant: Iff {@code getChildOrder(time).contains(child)} then
-     * {@code child.getParent(time) == this}.
-     */
-    private final List<DiffNode<L>>[] children = Cast.unchecked(Array.newInstance(List.class, 2));
+    private final TimeDependentState<L> stateBefore = new TimeDependentState<L>();
+    private final TimeDependentState<L> stateAfter = new TimeDependentState<L>();
 
-    /**
-     * Cache for before and after projections.
-     * It stores the projection node at each time so that only one instance of {@link Projection}
-     * per {@link Time} is ever created. This array has to be indexed by {@code Time.ordinal()}
-     *
-     * <p>This field is required to allow identity tests of {@link Projection}s with {@code ==}.
-     */
-    private Projection<L>[] projections = Cast.unchecked(Array.newInstance(Projection.class, 2));
+    private TimeDependentState<L> at(Time time) {
+        return time.match(stateBefore, stateAfter);
+    }
 
     /**
      * Creates a DiffNode with the given parameters.
@@ -104,9 +119,6 @@ public DiffNode(DiffType diffType, NodeType nodeType,
     public DiffNode(DiffType diffType,
                     DiffLineNumber fromLines, DiffLineNumber toLines,
                     Node featureMapping, VariationLabel<L> label) {
-        children[BEFORE.ordinal()] = new ArrayList<>();
-        children[AFTER.ordinal()] = new ArrayList<>();
-
         this.diffType = diffType;
         this.label = label;
         this.from = fromLines;
@@ -267,7 +279,7 @@ public void drop(Time time) {
      * Returns -1 if the given node is not a child of this node.
      */
     public int indexOfChild(final DiffNode<L> child, Time time) {
-        return children[time.ordinal()].indexOf(child);
+        return at(time).children.indexOf(child);
     }
 
     /**
@@ -278,8 +290,8 @@ public void insertChild(final DiffNode<L> child, int index, Time time) {
         Assert.assertFalse(isChild(child, time), () ->
             "Given child " + child + " already has a " + time + " parent (" + child.getParent(time) + ")!");
 
-        children[time.ordinal()].add(index, child);
-        child.parents[time.ordinal()] = this;
+        at(time).children.add(index, child);
+        child.at(time).parent = this;
     }
 
     /**
@@ -291,8 +303,8 @@ public void addChild(final DiffNode<L> child, Time time) {
         Assert.assertFalse(isChild(child, time), () ->
             "Given child " + child + " already has a " + time + " parent (" + child.getParent(time) + ")!");
 
-        children[time.ordinal()].add(child);
-        child.parents[time.ordinal()] = this;
+        at(time).children.add(child);
+        child.at(time).parent = this;
     }
 
     /**
@@ -315,8 +327,8 @@ public void addChildren(final Collection<DiffNode<L>> children, Time time) {
     public void removeChild(final DiffNode<L> child, Time time) {
         Assert.assertTrue(isChild(child, time));
 
-        child.parents[time.ordinal()] = null;
-        children[time.ordinal()].remove(child);
+        child.at(time).parent = null;
+        at(time).children.remove(child);
     }
 
     /**
@@ -341,12 +353,12 @@ public void removeChildren(final Collection<DiffNode<L>> childrenToRemove) {
      * @return All removed children.
      */
     public List<DiffNode<L>> removeChildren(Time time) {
-        for (var child : children[time.ordinal()]) {
-            child.parents[time.ordinal()] = null;
+        for (var child : at(time).children) {
+            child.at(time).parent = null;
         }
 
-        final List<DiffNode<L>> orphans = children[time.ordinal()];
-        children[time.ordinal()] = new ArrayList<>();
+        final List<DiffNode<L>> orphans = at(time).children;
+        at(time).children = new ArrayList<>();
         return orphans;
     }
 
@@ -387,10 +399,10 @@ public DiffNode<L> split(Time time) {
         getParent(time).replaceChild(this, other, time);
 
         // Preserve the projection by changing its `backingNode` to `other`.
-        if (this.projections[time.ordinal()] != null) {
-            other.projections[time.ordinal()] = this.projections[time.ordinal()];
-            this.projections[time.ordinal()] = null;
-            other.projections[time.ordinal()].backingNode = other;
+        if (this.at(time).projection != null) {
+            other.at(time).projection = this.at(time).projection;
+            this.at(time).projection = null;
+            other.at(time).projection.backingNode = other;
         }
 
         return other;
@@ -409,11 +421,11 @@ public void replaceChild(DiffNode<L> oldChild, DiffNode<L> newChild, Time time)
         Assert.assertNull(newChild.getParent(time));
         Assert.assertTrue(newChild.getDiffType().existsAtTime(time));
 
-        for (ListIterator<DiffNode<L>> it = children[time.ordinal()].listIterator(); it.hasNext(); ) {
+        for (ListIterator<DiffNode<L>> it = at(time).children.listIterator(); it.hasNext(); ) {
             if (it.next() == oldChild) {
                 it.set(newChild);
-                newChild.parents[time.ordinal()] = oldChild.parents[time.ordinal()];
-                oldChild.parents[time.ordinal()] = null;
+                newChild.at(time).parent = oldChild.at(time).parent;
+                oldChild.at(time).parent = null;
                 break;
             }
         }
@@ -423,7 +435,7 @@ public void replaceChild(DiffNode<L> oldChild, DiffNode<L> newChild, Time time)
      * Returns the parent of this node before or after the edit.
      */
     public DiffNode<L> getParent(Time time) {
-        return parents[time.ordinal()];
+        return at(time).parent;
     }
 
     /**
@@ -503,7 +515,7 @@ public void setFormula(Node featureMapping) {
      * Returns the order of the children at {@code time}.
      */
     public List<DiffNode<L>> getChildOrder(Time time) {
-        return Collections.unmodifiableList(children[time.ordinal()]);
+        return Collections.unmodifiableList(at(time).children);
     }
 
     /**
@@ -513,8 +525,8 @@ public List<DiffNode<L>> getChildOrder(Time time) {
      */
     public Stream<DiffNode<L>> getAllChildrenStream() {
         return Stream.concat(
-            children[BEFORE.ordinal()].stream(),
-            children[AFTER.ordinal()].stream().filter(child -> child.getParent(BEFORE) != this)
+            at(BEFORE).children.stream(),
+            at(AFTER).children.stream().filter(child -> child.getParent(BEFORE) != this)
         );
     };
 
@@ -578,7 +590,7 @@ public boolean isChild(DiffNode<L> child, Time time) {
      * Returns true iff this node has no children.
      */
     public boolean isLeaf() {
-        return children[BEFORE.ordinal()].isEmpty() && children[AFTER.ordinal()].isEmpty();
+        return at(BEFORE).children.isEmpty() && at(AFTER).children.isEmpty();
     }
 
     /**
@@ -750,11 +762,11 @@ public void assertConsistency() {
     public Projection<L> projection(Time time) {
         Assert.assertTrue(getDiffType().existsAtTime(time));
 
-        if (projections[time.ordinal()] == null) {
-            projections[time.ordinal()] = new Projection<>(this, time);
+        if (at(time).projection == null) {
+            at(time).projection = new Projection<>(this, time);
         }
 
-        return projections[time.ordinal()];
+        return at(time).projection;
     }
 
     /**