Skip to content

Commit 1ecde7d

Browse files
ibbemibbem
committed
Document and rename WrappedVariationTree to VariationTreeAdapter
1 parent 15b616c commit 1ecde7d

4 files changed

Lines changed: 60 additions & 46 deletions

File tree

‎src/main/java/org/variantsync/diffdetective/gumtree/DiffTreeAdapter.java‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package org.variantsync.diffdetective.gumtree;
2+
3+
import org.variantsync.diffdetective.variation.diff.DiffNode;
4+
import org.variantsync.diffdetective.variation.diff.Projection;
5+
import org.variantsync.diffdetective.variation.diff.Time;
6+
import org.variantsync.diffdetective.variation.tree.VariationNode;
7+
8+
/**
9+
* Adapter for running Gumtree's matching algorithms on the projections of variation diffs.
10+
*
11+
* This class is almost identical to {@link VariationTreeAdapter} except that it provides type safe
12+
* access to the projected {@link DiffNode}.
13+
*/
14+
public class DiffTreeAdapter extends VariationTreeAdapter {
15+
public DiffTreeAdapter(DiffNode node, Time time) {
16+
super(node.projection(time));
17+
}
18+
19+
public DiffTreeAdapter(Projection node) {
20+
super(node);
21+
}
22+
23+
protected VariationTreeAdapter newInstance(VariationNode<?> node) {
24+
return new DiffTreeAdapter((Projection)node);
25+
}
26+
27+
public DiffNode getDiffNode() {
28+
return ((Projection)getVariationNode()).getBackingNode();
29+
}
30+
}

src/main/java/org/variantsync/diffdetective/gumtree/WrappedVariationTree.java renamed to src/main/java/org/variantsync/diffdetective/gumtree/VariationTreeAdapter.java

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,19 @@
1212
import com.github.gumtreediff.tree.Type;
1313
import com.github.gumtreediff.tree.TypeSet;
1414

15-
public class WrappedVariationTree extends AbstractTree {
15+
/**
16+
* Adapter for running Gumtree's matching algorithms on variation trees.
17+
*
18+
* This class is an <a href="https://en.wikipedia.org/wiki/Adapter_pattern">adapter</a> for a
19+
* snapshot of a variation tree. This means that it doesn't reflect most changes to the underlying
20+
* variation tree. Essentially it creates a copy of the tree structure and the labels of a variation
21+
* tree by stores a reference to the variation node which it adapts.
22+
*/
23+
public class VariationTreeAdapter extends AbstractTree {
1624
private String cachedLabel;
1725
private VariationNode<?> backingNode;
1826

19-
public WrappedVariationTree(VariationNode<?> node) {
27+
public VariationTreeAdapter(VariationNode<?> node) {
2028
this.backingNode = node;
2129

2230
if (backingNode.isConditionalAnnotation()) {
@@ -32,8 +40,8 @@ public WrappedVariationTree(VariationNode<?> node) {
3240
setChildren(children);
3341
}
3442

35-
protected WrappedVariationTree newInstance(VariationNode<?> node) {
36-
return new WrappedVariationTree(node);
43+
protected VariationTreeAdapter newInstance(VariationNode<?> node) {
44+
return new VariationTreeAdapter(node);
3745
}
3846

3947
public VariationNode<?> getVariationNode() {

‎src/main/java/org/variantsync/diffdetective/gumtree/WrappedDiffTree.java‎

Lines changed: 0 additions & 24 deletions
This file was deleted.

‎src/main/java/org/variantsync/diffdetective/variation/diff/DiffTree.java‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,8 @@
1616
import org.variantsync.diffdetective.diff.result.DiffError;
1717
import org.variantsync.diffdetective.diff.result.DiffParseException;
1818
import org.variantsync.diffdetective.diff.text.DiffLineNumber;
19-
import org.variantsync.diffdetective.gumtree.WrappedDiffTree;
20-
import org.variantsync.diffdetective.gumtree.WrappedVariationTree;
19+
import org.variantsync.diffdetective.gumtree.DiffTreeAdapter;
20+
import org.variantsync.diffdetective.gumtree.VariationTreeAdapter;
2121
import org.variantsync.diffdetective.util.Assert;
2222
import org.variantsync.diffdetective.variation.diff.parse.DiffTreeParseOptions;
2323
import org.variantsync.diffdetective.variation.diff.parse.DiffTreeParser;
@@ -512,15 +512,15 @@ public static <B extends VariationNode<B>> DiffNode compareUsingMatching(
512512
VariationNode<B> after,
513513
Matcher matcher
514514
) {
515-
var src = new WrappedDiffTree(before, BEFORE);
516-
var dst = new WrappedVariationTree(after);
515+
var src = new DiffTreeAdapter(before, BEFORE);
516+
var dst = new VariationTreeAdapter(after);
517517

518518
MappingStore matching = matcher.match(src, dst);
519519
Assert.assertTrue(matching.has(src, dst));
520520

521521
removeUnmapped(matching, src);
522522
for (var child : dst.getChildren()) {
523-
addUnmapped(matching, src.getDiffNode(), (WrappedVariationTree)child);
523+
addUnmapped(matching, src.getDiffNode(), (VariationTreeAdapter)child);
524524
}
525525

526526
int[] currentID = new int[1];
@@ -533,18 +533,18 @@ public static <B extends VariationNode<B>> DiffNode compareUsingMatching(
533533
return before;
534534
}
535535

536-
private static void removeUnmapped(MappingStore mappings, WrappedDiffTree root) {
536+
private static void removeUnmapped(MappingStore mappings, DiffTreeAdapter root) {
537537
for (var node : root.preOrder()) {
538538
Tree dst = mappings.getDstForSrc(node);
539539
if (dst == null || !dst.getLabel().equals(node.getLabel())) {
540-
var diffNode = ((WrappedDiffTree)node).getDiffNode();
540+
var diffNode = ((DiffTreeAdapter)node).getDiffNode();
541541
diffNode.diffType = REM;
542542
diffNode.drop(AFTER);
543543
}
544544
}
545545
}
546546

547-
private static void addUnmapped(MappingStore mappings, DiffNode parent, WrappedVariationTree afterNode) {
547+
private static void addUnmapped(MappingStore mappings, DiffNode parent, VariationTreeAdapter afterNode) {
548548
VariationNode<?> variationNode = afterNode.getVariationNode();
549549
DiffNode diffNode;
550550

@@ -562,7 +562,7 @@ private static void addUnmapped(MappingStore mappings, DiffNode parent, WrappedV
562562
variationNode.getLabelLines()
563563
);
564564
} else {
565-
diffNode = ((WrappedDiffTree)src).getDiffNode();
565+
diffNode = ((DiffTreeAdapter)src).getDiffNode();
566566
if (diffNode.getParent(AFTER) != null) {
567567
diffNode.drop(AFTER);
568568
}
@@ -571,7 +571,7 @@ private static void addUnmapped(MappingStore mappings, DiffNode parent, WrappedV
571571

572572
diffNode.removeChildren(AFTER);
573573
for (var child : afterNode.getChildren()) {
574-
addUnmapped(mappings, diffNode, (WrappedVariationTree)child);
574+
addUnmapped(mappings, diffNode, (VariationTreeAdapter)child);
575575
}
576576
}
577577

@@ -588,8 +588,8 @@ public void improveMatching(Matcher matcher) {
588588
* in-place to reflect the new matching.
589589
*/
590590
public static DiffNode improveMatching(DiffNode tree, Matcher matcher) {
591-
var src = new WrappedDiffTree(tree, BEFORE);
592-
var dst = new WrappedDiffTree(tree, AFTER);
591+
var src = new DiffTreeAdapter(tree, BEFORE);
592+
var dst = new DiffTreeAdapter(tree, AFTER);
593593

594594
MappingStore matching = new MappingStore(src, dst);
595595
extractMatching(src, dst, matching);
@@ -598,15 +598,15 @@ public static DiffNode improveMatching(DiffNode tree, Matcher matcher) {
598598

599599
for (var srcNode : src.preOrder()) {
600600
var dstNode = matching.getDstForSrc(srcNode);
601-
var beforeNode = ((WrappedDiffTree)srcNode).getDiffNode();
601+
var beforeNode = ((DiffTreeAdapter)srcNode).getDiffNode();
602602
if (dstNode == null || !srcNode.getLabel().equals(dstNode.getLabel())) {
603603
if (beforeNode.isNon()) {
604604
splitNode(beforeNode);
605605
}
606606

607607
Assert.assertTrue(beforeNode.isRem());
608608
} else {
609-
var afterNode = ((WrappedDiffTree)dstNode).getDiffNode();
609+
var afterNode = ((DiffTreeAdapter)dstNode).getDiffNode();
610610

611611
if (beforeNode != afterNode) {
612612
if (beforeNode.isNon()) {
@@ -660,21 +660,21 @@ private static void joinNode(DiffNode beforeNode, DiffNode afterNode) {
660660
}
661661

662662
private static void extractMatching(
663-
WrappedDiffTree src,
664-
WrappedDiffTree dst,
663+
DiffTreeAdapter src,
664+
DiffTreeAdapter dst,
665665
MappingStore result
666666
) {
667667
Map<DiffNode, Tree> matching = new HashMap<>();
668668

669669
for (var srcNode : src.preOrder()) {
670-
DiffNode diffNode = ((WrappedDiffTree)srcNode).getDiffNode();
670+
DiffNode diffNode = ((DiffTreeAdapter)srcNode).getDiffNode();
671671
if (diffNode.isNon()) {
672672
matching.put(diffNode, srcNode);
673673
}
674674
}
675675

676676
for (var dstNode : dst.preOrder()) {
677-
DiffNode diffNode = ((WrappedDiffTree)dstNode).getDiffNode();
677+
DiffNode diffNode = ((DiffTreeAdapter)dstNode).getDiffNode();
678678
if (diffNode.isNon()) {
679679
Assert.assertTrue(matching.get(diffNode) != null);
680680
result.addMapping(matching.get(diffNode), dstNode);

0 commit comments

Comments
 (0)