Rename CodeType to NodeType

Author: ibbem

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

@@ -17,7 +17,7 @@
 /**
  * Implementation of a node in a {@link DiffTree}.
  *
- * Includes methods for creating a node by getting its code type and diff type and for getting the feature mapping of the node.
+ * Includes methods for creating a node by getting its node type and diff type and for getting the feature mapping of the node.
  * @author Paul Bittner, Sören Viegener, Benjamin Moosherr
  */
 public class DiffNode {
@@ -30,10 +30,10 @@ public class DiffNode {
     public final DiffType diffType;
 
     /**
-     * The code type of this node, which determines the type of the represented
+     * The node type of this node, which determines the type of the represented
      * element in the diff (e.g., mapping or artifact).
      */
-    public final CodeType codeType;
+    public final NodeType nodeType;
 
     private boolean isMultilineMacro = false;
 
@@ -73,30 +73,30 @@ public class DiffNode {
     /**
      * Creates a DiffNode with the given parameters.
      * @param diffType The type of change made to this node.
-     * @param codeType The type of this node (i.e., mapping or artifact).
+     * @param nodeType The type of this node (i.e., mapping or artifact).
      * @param fromLines The starting line number of the corresponding text.
      * @param toLines The ending line number of the corresponding text.
      * @param featureMapping The formula stored in this node. Should be null for code (/artifact) nodes.
      * @param label A text label containing information to identify the node (such as the corresponding source code).
      */
-    public DiffNode(DiffType diffType, CodeType codeType,
+    public DiffNode(DiffType diffType, NodeType nodeType,
                     DiffLineNumber fromLines, DiffLineNumber toLines,
                     Node featureMapping, String label) {
-        this(diffType, codeType, fromLines, toLines, featureMapping,
+        this(diffType, nodeType, fromLines, toLines, featureMapping,
                 new ArrayList<String>(Arrays.asList(StringUtils.LINEBREAK_REGEX.split(label, -1))));
     }
 
     /**
-     * The same as {@link DiffNode#DiffNode(DiffType, CodeType, DiffLineNumber, DiffLineNumber, Node, String)}
+     * The same as {@link DiffNode#DiffNode(DiffType, NodeType, DiffLineNumber, DiffLineNumber, Node, String)}
      * but with the label separated into different lines of text instead of as a single String with newlines.
      */
-    public DiffNode(DiffType diffType, CodeType codeType,
+    public DiffNode(DiffType diffType, NodeType nodeType,
                     DiffLineNumber fromLines, DiffLineNumber toLines,
                     Node featureMapping, List<String> lines) {
         this.childOrder = new ArrayList<>();
 
         this.diffType = diffType;
-        this.codeType = codeType;
+        this.nodeType = nodeType;
         this.from.set(fromLines);
         this.to.set(toLines);
         this.featureMapping = featureMapping;
@@ -110,7 +110,7 @@ public DiffNode(DiffType diffType, CodeType codeType,
     public static DiffNode createRoot() {
         return new DiffNode(
                 DiffType.NON,
-                CodeType.ROOT,
+                NodeType.ROOT,
                 new DiffLineNumber(1, 1, 1),
                 DiffLineNumber.Invalid(),
                 FixTrueFalse.True,
@@ -120,19 +120,19 @@ public static DiffNode createRoot() {
 
     /**
      * Creates an artifact node with the given parameters.
-     * For parameter descriptions, see {@link DiffNode#DiffNode(DiffType, CodeType, DiffLineNumber, DiffLineNumber, Node, String)}.
+     * For parameter descriptions, see {@link DiffNode#DiffNode(DiffType, NodeType, DiffLineNumber, DiffLineNumber, Node, String)}.
      * The <code>code</code> parameter will be set as the node's label.
      */
     public static DiffNode createCode(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, String code) {
-        return new DiffNode(diffType, CodeType.CODE, fromLines, toLines, null, code);
+        return new DiffNode(diffType, NodeType.CODE, fromLines, toLines, null, code);
     }
 
     /**
      * The same as {@link DiffNode#createCode(DiffType, DiffLineNumber, DiffLineNumber, String)} but with the code for the label
      * given as a list of individual lines instead of a single String with linebreaks to identify newlines.
      */
     public static DiffNode createCode(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, List<String> lines) {
-        return new DiffNode(diffType, CodeType.CODE, fromLines, toLines, null, lines);
+        return new DiffNode(diffType, NodeType.CODE, fromLines, toLines, null, lines);
     }
 
     /**
@@ -651,9 +651,9 @@ public Lines getLinesAfterEdit() {
 
     /**
      * Returns the formula that is stored in this node.
-     * The formula is null for artifact nodes (i.e., {@link CodeType#CODE}).
+     * The formula is null for artifact nodes (i.e., {@link NodeType#CODE}).
      * The formula is not null for mapping nodes
-     * @see CodeType#isMacro
+     * @see NodeType#isMacro
      */
     public Node getDirectFeatureMapping() {
         return featureMapping;
@@ -691,9 +691,9 @@ public boolean isMultilineMacro() {
 
     /**
      * Returns the full feature mapping formula of this node.
-     * The feature mapping of an {@link CodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
-     * The feature mapping of {@link CodeType#ELSE} and {@link CodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link CodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
+     * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
+     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @param parentOf Function that returns the parent of a node.
      *                 This function decides whether the before or after parent should be visited.
@@ -717,7 +717,7 @@ private List<Node> getFeatureMappingClauses(final Function<DiffNode, DiffNode> p
                 if (ancestor.isElif()) {
                     and.add(negate(ancestor.getDirectFeatureMapping()));
                 } else {
-                    throw new RuntimeException("Expected If or Elif above Else or Elif but got " + ancestor.codeType + " from " + ancestor);
+                    throw new RuntimeException("Expected If or Elif above Else or Elif but got " + ancestor.nodeType + " from " + ancestor);
                     // Assert.assertTrue(ancestor.isCode());
                 }
                 ancestor = parentOf.apply(ancestor);
@@ -745,9 +745,9 @@ private Node getFeatureMapping(Function<DiffNode, DiffNode> parentOf) {
 
     /**
      * Returns the full feature mapping formula of this node before the edit.
-     * The feature mapping of an {@link CodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
-     * The feature mapping of {@link CodeType#ELSE} and {@link CodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link CodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
+     * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
+     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @return The feature mapping of this node for the given parent edges.
      */
@@ -757,9 +757,9 @@ public Node getBeforeFeatureMapping() {
 
     /**
      * Returns the full feature mapping formula of this node after the edit.
-     * The feature mapping of an {@link CodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
-     * The feature mapping of {@link CodeType#ELSE} and {@link CodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link CodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
+     * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
+     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @return The feature mapping of this node for the given parent edges.
      */
@@ -928,57 +928,57 @@ public DiffType getDiffType() {
 
     /**
      * Returns true if this node represents an ELIF macro.
-     * @see CodeType#ELIF
+     * @see NodeType#ELIF
      */
     public boolean isElif() {
-        return this.codeType.equals(CodeType.ELIF);
+        return this.nodeType.equals(NodeType.ELIF);
     }
 
     /**
      * Returns true if this node represents a conditional annotation.
-     * @see CodeType#IF
+     * @see NodeType#IF
      */
     public boolean isIf() {
-        return this.codeType.equals(CodeType.IF);
+        return this.nodeType.equals(NodeType.IF);
     }
 
     /**
      * Returns true if this node is an artifact node.
-     * @see CodeType#CODE
+     * @see NodeType#CODE
      */
     public boolean isCode() {
-        return this.codeType.equals(CodeType.CODE);
+        return this.nodeType.equals(NodeType.CODE);
     }
 
     /**
      * Returns true if this node represents the end of an annotation block.
      * Such a node should not be part of any {@link DiffTree}.
-     * @see CodeType#ENDIF
+     * @see NodeType#ENDIF
      */
     public boolean isEndif() {
-        return this.codeType.equals(CodeType.ENDIF);
+        return this.nodeType.equals(NodeType.ENDIF);
     }
 
     /**
      * Returns true if this node represents an ELSE macro.
-     * @see CodeType#ELSE
+     * @see NodeType#ELSE
      */
     public boolean isElse() {
-        return this.codeType.equals(CodeType.ELSE);
+        return this.nodeType.equals(NodeType.ELSE);
     }
 
     /**
-     * Returns true if this node is a root node (i.e., it has {@link CodeType#ROOT}.
+     * Returns true if this node is a root node (i.e., it has {@link NodeType#ROOT}.
      */
     public boolean isRoot() {
-        return this.codeType.equals(CodeType.ROOT);
+        return this.nodeType.equals(NodeType.ROOT);
     }
 
     /**
-     * Returns {@link CodeType#isMacro()} for this node's {@link DiffNode#codeType}.
+     * Returns {@link NodeType#isMacro()} for this node's {@link DiffNode#nodeType}.
      */
     public boolean isMacro() {
-        return this.codeType.isMacro();
+        return this.nodeType.isMacro();
     }
 
     /**
@@ -999,13 +999,13 @@ public int getID() {
         id <<= ID_OFFSET;
         id += diffType.ordinal();
         id <<= ID_OFFSET;
-        id += codeType.ordinal();
+        id += nodeType.ordinal();
         return id;
     }
 
     /**
      * Reconstructs a node from the given id and sets the given label.
-     * An id uniquely determines a node's {@link DiffNode#codeType}, {@link DiffNode#diffType}, and {@link DiffLineNumber#inDiff line number in the diff}.
+     * An id uniquely determines a node's {@link DiffNode#nodeType}, {@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.
@@ -1014,13 +1014,13 @@ public int getID() {
     public static DiffNode fromID(final int id, String label) {
         final int lowestBitsMask = (1 << ID_OFFSET) - 1;
 
-        final int codeTypeOrdinal = id & lowestBitsMask;
+        final int nodeTypeOrdinal = id & lowestBitsMask;
         final int diffTypeOrdinal = (id >> ID_OFFSET) & lowestBitsMask;
         final int fromInDiff      = (id >> (2*ID_OFFSET)) - 1;
 
         return new DiffNode(
                 DiffType.values()[diffTypeOrdinal],
-                CodeType.values()[codeTypeOrdinal],
+                NodeType.values()[nodeTypeOrdinal],
                 new DiffLineNumber(fromInDiff, DiffLineNumber.InvalidLineNumber, DiffLineNumber.InvalidLineNumber),
                 DiffLineNumber.Invalid(),
                 null,
@@ -1117,7 +1117,7 @@ public String toTextDiff() {
         // Add endif after macro
         if (isMacro()) {
             diff
-                    .append(toTextDiffLine(this.diffType, List.of(CodeType.ENDIF.asMacroText())))
+                    .append(toTextDiffLine(this.diffType, List.of(NodeType.ENDIF.asMacroText())))
                     .append(StringUtils.LINEBREAK);
         }
 
@@ -1128,11 +1128,11 @@ public String toTextDiff() {
     public String toString() {
         String s;
         if (isCode()) {
-            s = String.format("%s_%s from %d to %d", diffType, codeType, from.inDiff, to.inDiff);
+            s = String.format("%s_%s from %d to %d", diffType, nodeType, from.inDiff, to.inDiff);
         } else if (isRoot()) {
             s = "ROOT";
         } else {
-            s = String.format("%s_%s from %d to %d with \"%s\"", diffType, codeType,
+            s = String.format("%s_%s from %d to %d with \"%s\"", diffType, nodeType,
                     from.inDiff, to.inDiff, featureMapping);
         }
         return s;
@@ -1143,7 +1143,7 @@ public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         DiffNode diffNode = (DiffNode) o;
-        return isMultilineMacro == diffNode.isMultilineMacro && diffType == diffNode.diffType && codeType == diffNode.codeType && from.equals(diffNode.from) && to.equals(diffNode.to) && Objects.equals(featureMapping, diffNode.featureMapping) && lines.equals(diffNode.lines);
+        return isMultilineMacro == diffNode.isMultilineMacro && diffType == diffNode.diffType && nodeType == diffNode.nodeType && from.equals(diffNode.from) && to.equals(diffNode.to) && Objects.equals(featureMapping, diffNode.featureMapping) && lines.equals(diffNode.lines);
     }
 
     /**
@@ -1156,6 +1156,6 @@ public boolean equals(Object o) {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(diffType, codeType, isMultilineMacro, from, to, featureMapping, lines);
+        return Objects.hash(diffType, nodeType, isMultilineMacro, from, to, featureMapping, lines);
     }
 }

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffTree.java

@@ -73,7 +73,7 @@ public static DiffResult<DiffTree> fromDiff(final String diff, boolean collapseM
      * So just lines preceded by "+", "-", or " " are expected.
      * @param p Path to a diff file.
      * @param collapseMultipleCodeLines Set to true if subsequent lines of source code with
-     *                                  the same {@link CodeType type of change} should be
+     *                                  the same {@link NodeType type of change} should be
      *                                  collapsed into a single source code node representing
      *                                  all lines at once.
      * @param ignoreEmptyLines Set to true if empty lines should not be included in the DiffTree.
@@ -95,7 +95,7 @@ public static DiffResult<DiffTree> fromFile(final Path p, boolean collapseMultip
      * So just lines preceded by "+", "-", or " " are expected.
      * @param diff The diff as text. Lines should be separated by a newline character. Each line should be preceded by either "+", "-", or " ".
      * @param collapseMultipleCodeLines Set to true if subsequent lines of source code with
-     *                                  the same {@link CodeType type of change} should be
+     *                                  the same {@link NodeType type of change} should be
      *                                  collapsed into a single source code node representing
      *                                  all lines at once.
      * @param ignoreEmptyLines Set to true if empty lines should not be included in the DiffTree.

…iffdetective/diff/difftree/CodeType.java …iffdetective/diff/difftree/NodeType.javasrc/main/java/org/variantsync/diffdetective/diff/difftree/CodeType.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/NodeType.java src/main/java/org/variantsync/diffdetective/diff/difftree/CodeType.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/NodeType.java

@@ -7,7 +7,7 @@
  * The type of nodes in a {@link DiffTree}.
  * Corresponds to the tau function from our paper.
  */
-public enum CodeType {
+public enum NodeType {
     // Mapping types
     IF("if"),
     ENDIF("endif"),
@@ -21,32 +21,32 @@ public enum CodeType {
     ROOT("ROOT");
 
     public final String name;
-    CodeType(String name) {
+    NodeType(String name) {
         this.name = name;
     }
 
     /**
-     * Returns true iff this code type represents a conditional feature annotation (i.e., if or elif).
+     * Returns true iff this node type represents a conditional feature annotation (i.e., if or elif).
      */
     public boolean isConditionalMacro() {
         return this == IF || this == ELIF;
     }
 
     /**
-     * Returns true iff this code type represents a feature mapping.
+     * Returns true iff this node type represents a feature mapping.
      */
-    public boolean isMacro() {
+    public boolean isAnnotation() {
         return this != ROOT && this != CODE;
     }
 
     final static Pattern annotationRegex = Pattern.compile("^[+-]?\\s*#\\s*(if|endif|else|elif)");
 
     /**
-     * Parses the code type from a line taken from a text-based diff.
+     * Parses the node type from a line taken from a text-based diff.
      * @param line A line in a patch.
      * @return The type of edit of <code>line</code>.
      */
-    public static CodeType ofDiffLine(String line) {
+    public static NodeType ofDiffLine(String line) {
         Matcher matcher = annotationRegex.matcher(line);
         if (matcher.find()) {
             String id = matcher.group(1);
@@ -65,19 +65,19 @@ public static CodeType ofDiffLine(String line) {
     }
 
     /**
-     * Creates a CodeType from its value names.
+     * Creates a NodeType from its value names.
      * @see Enum#name()
      * @param name a string that equals the name of one value of this enum (ignoring case)
-     * @return The CodeType that has the given name
+     * @return The NodeType that has the given name
      */
-    public static CodeType fromName(final String name) {
-        for (CodeType candidate : values()) {
+    public static NodeType fromName(final String name) {
+        for (NodeType candidate : values()) {
             if (candidate.toString().equalsIgnoreCase(name)) {
                 return candidate;
             }
         }
 
-        throw new IllegalArgumentException("Given string \"" + name + "\" is not the name of a CodeType.");
+        throw new IllegalArgumentException("Given string \"" + name + "\" is not the name of a NodeType.");
     }
 
     /**