Uses of Class
org.variantsync.diffdetective.variation.diff.DiffNode

Packages that use DiffNode

Package	Description
org.variantsync.diffdetective.editclass
org.variantsync.diffdetective.editclass.proposed
org.variantsync.diffdetective.examplesearch
org.variantsync.diffdetective.experiments.thesis_bm
org.variantsync.diffdetective.gumtree
org.variantsync.diffdetective.internal
org.variantsync.diffdetective.mining
org.variantsync.diffdetective.mining.formats
org.variantsync.diffdetective.show.variation
org.variantsync.diffdetective.variation.diff
org.variantsync.diffdetective.variation.diff.bad
org.variantsync.diffdetective.variation.diff.construction
org.variantsync.diffdetective.variation.diff.graph
org.variantsync.diffdetective.variation.diff.parse
org.variantsync.diffdetective.variation.diff.serialize
org.variantsync.diffdetective.variation.diff.serialize.edgeformat
org.variantsync.diffdetective.variation.diff.serialize.nodeformat
org.variantsync.diffdetective.variation.diff.transform
org.variantsync.diffdetective.variation.diff.traverse
org.variantsync.diffdetective.variation.tree

Uses of DiffNode in org.variantsync.diffdetective.editclass

Methods in org.variantsync.diffdetective.editclass with parameters of type DiffNode

Modifier and Type	Method	Description
default EditClass	EditClassCatalogue.match(DiffNode<?> node)	Returns the edit class that matches the given node.
final boolean	EditClass.matches(DiffNode<?> node)	Returns true if this edit class matches the given node and is an artifact.
protected abstract boolean	EditClass.matchesArtifactNode(DiffNode<?> artifactNode)	Returns true iff the given node matches this edit class.

Uses of DiffNode in org.variantsync.diffdetective.editclass.proposed

Methods in org.variantsync.diffdetective.editclass.proposed with parameters of type DiffNode

Modifier and Type	Method	Description
EditClass	ProposedEditClasses.match(DiffNode<?> node)
protected boolean	AddToPC.matchesArtifactNode(DiffNode<?> node)
protected boolean	AddWithMapping.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	Generalization.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	Reconfiguration.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	Refactoring.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	RemFromPC.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	RemWithMapping.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	Specialization.matchesArtifactNode(DiffNode<?> artifactNode)
protected boolean	Untouched.matchesArtifactNode(DiffNode<?> artifactNode)

Uses of DiffNode in org.variantsync.diffdetective.examplesearch

Methods in org.variantsync.diffdetective.examplesearch with parameters of type DiffNode

Modifier and Type	Method	Description
private static boolean	ExampleCriterions.isNested(DiffNode<?> n)
private static boolean	ExampleCriterions.isNestedAt(DiffNode<?> n, Time t)

Uses of DiffNode in org.variantsync.diffdetective.experiments.thesis_bm

Method parameters in org.variantsync.diffdetective.experiments.thesis_bm with type arguments of type DiffNode

Modifier and Type	Method	Description
private <L extends Label> void	ConstructionValidation.parallelPreOrderWalk(Projection<L> nodeA, Projection<L> nodeB, BiConsumer<DiffNode<L>,DiffNode<L>> consumer, Set<DiffNode<L>> visited)
private <L extends Label> void	ConstructionValidation.parallelPreOrderWalk(Projection<L> nodeA, Projection<L> nodeB, BiConsumer<DiffNode<L>,DiffNode<L>> consumer, Set<DiffNode<L>> visited)
private <L extends Label> void	ConstructionValidation.parallelPreOrderWalk(Projection<L> nodeA, Projection<L> nodeB, BiConsumer<DiffNode<L>,DiffNode<L>> consumer, Set<DiffNode<L>> visited)
private <L extends Label> void	ConstructionValidation.parallelPreOrderWalk(VariationDiff<L> nodeA, VariationDiff<L> nodeB, BiConsumer<DiffNode<L>,DiffNode<L>> consumer)
private <L extends Label> void	ConstructionValidation.parallelPreOrderWalk(VariationDiff<L> nodeA, VariationDiff<L> nodeB, BiConsumer<DiffNode<L>,DiffNode<L>> consumer)

Uses of DiffNode in org.variantsync.diffdetective.gumtree

Methods in org.variantsync.diffdetective.gumtree that return DiffNode

Modifier and Type	Method	Description
DiffNode<L>	VariationDiffAdapter.getDiffNode()

Constructors in org.variantsync.diffdetective.gumtree with parameters of type DiffNode

Modifier	Constructor	Description
	VariationDiffAdapter(DiffNode<L> node, Time time)

Uses of DiffNode in org.variantsync.diffdetective.internal

Methods in org.variantsync.diffdetective.internal with parameters of type DiffNode

Modifier and Type	Method	Description
static String	TextDiffToTikz.tikzNodeLabel(DiffNode<? extends DiffLinesLabel> node)

Uses of DiffNode in org.variantsync.diffdetective.mining

Methods in org.variantsync.diffdetective.mining with parameters of type DiffNode

Modifier and Type	Method	Description
String	RWCompositePatternNodeFormat.toLabel(DiffNode<? extends DiffLinesLabel> node)

Uses of DiffNode in org.variantsync.diffdetective.mining.formats

Fields in org.variantsync.diffdetective.mining.formats declared as DiffNode

Modifier and Type	Field	Description
private final DiffNode<L>	DirectedEdgeLabelFormat.Edge.from	The field for the from record component.
private final DiffNode<L>	DirectedEdgeLabelFormat.Edge.to	The field for the to record component.

Methods in org.variantsync.diffdetective.mining.formats that return DiffNode

Modifier and Type	Method	Description
DiffNode<L>	DirectedEdgeLabelFormat.Edge.from()	Returns the value of the from record component.
default DiffNode<DiffLinesLabel>	MiningNodeFormat.fromLabelAndId(String lineGraphNodeLabel, int nodeId)
DiffNode<L>	DirectedEdgeLabelFormat.Edge.to()	Returns the value of the to record component.

Methods in org.variantsync.diffdetective.mining.formats with parameters of type DiffNode

Modifier and Type	Method	Description
protected <L extends DiffLinesLabel> void	DirectedEdgeLabelFormat.connectAccordingToLabel(DiffNode<L> child, DiffNode<L> parent, String edgeLabel)
private <L extends DiffLinesLabel> DirectedEdgeLabelFormat.Edge<L>	DirectedEdgeLabelFormat.recoverEdgeDirectionFromLabelIfPossible(DiffNode<L> hypothesizedFrom, DiffNode<L> hypothesizedTo, String edgeLabel)
String	DebugMiningDiffNodeFormat.toLabel(DiffNode<? extends DiffLinesLabel> node)
String	ReleaseMiningDiffNodeFormat.toLabel(DiffNode<? extends DiffLinesLabel> node)

Constructors in org.variantsync.diffdetective.mining.formats with parameters of type DiffNode

Modifier	Constructor	Description
private	Edge(DiffNode<L> from, DiffNode<L> to)	Creates an instance of a Edge record class.

Uses of DiffNode in org.variantsync.diffdetective.show.variation

Fields in org.variantsync.diffdetective.show.variation declared as DiffNode

Modifier and Type	Field	Description
protected final DiffNode<L>	NodeView.node

Fields in org.variantsync.diffdetective.show.variation with type parameters of type DiffNode

Modifier and Type	Field	Description
protected final Map<DiffNode<L>,Entity>	VariationDiffApp.nodes

Methods in org.variantsync.diffdetective.show.variation that return types with arguments of type DiffNode

Modifier and Type	Method	Description
static <L extends Label> Map<DiffNode<?>,Vec2>	VariationDiffApp.calculateLayout(VariationDiff<L> d, GraphvizExporter.LayoutAlgorithm layout, Format<L> format)

Methods in org.variantsync.diffdetective.show.variation with parameters of type DiffNode

Modifier and Type	Method	Description
Entity	VariationDiffApp.getEntityOf(DiffNode<?> diffNode)

Method parameters in org.variantsync.diffdetective.show.variation with type arguments of type DiffNode

Modifier and Type	Method	Description
void	VariationDiffApp.locateVariationDiffNodesAt(Map<DiffNode<?>,Vec2> locations)

Constructors in org.variantsync.diffdetective.show.variation with parameters of type DiffNode

Modifier	Constructor	Description
protected	NodeView(DiffNode<L> node, VariationDiffApp<L> formatHolder)

Uses of DiffNode in org.variantsync.diffdetective.variation.diff

Fields in org.variantsync.diffdetective.variation.diff declared as DiffNode

Modifier and Type	Field	Description
private DiffNode<L>	Projection.backingNode
private DiffNode<L>[]	DiffNode.parents	The parents DiffNode before and after the edit.
private final DiffNode<?>	VariationDiff.AllPathsEndAtRoot.root
private final DiffNode<L>	VariationDiff.root

Fields in org.variantsync.diffdetective.variation.diff with type parameters of type DiffNode

Modifier and Type	Field	Description
private final Map<DiffNode<?>,VariationDiff.AllPathsEndAtRoot.VisitStatus>	VariationDiff.AllPathsEndAtRoot.cache

Methods in org.variantsync.diffdetective.variation.diff that return DiffNode

Modifier and Type	Method	Description
static DiffNode<DiffLinesLabel>	DiffNode.createArtifact(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, String code)	Creates an artifact node with the given parameters.
static <L extends Label> DiffNode<L>	DiffNode.createArtifact(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, L label)	The same as createArtifact(DiffType, DiffLineNumber, DiffLineNumber, String) but with a generic label.
static <L extends Label> DiffNode<L>	DiffNode.createRoot(L label)	Creates a new root node.
DiffNode<L>	DiffNode.deepCopy()
DiffNode<L>	DiffNode.deepCopy(HashMap<DiffNode<L>,DiffNode<L>> oldToNew)
static DiffNode<DiffLinesLabel>	DiffNode.fromID(int id, String label)	Reconstructs a node from the given id and sets the given label.
DiffNode<L>	Projection.getBackingNode()
DiffNode<L>	DiffNode.getIfNode(Time time)	Gets the first if node in the path from the root to this node at the time time.
DiffNode<L>	VariationDiff.getNodeWithID(int id)	Obtain the DiffNode with the given id in this VariationDiff.
DiffNode<L>	DiffNode.getParent(Time time)	Returns the parent of this node before or after the edit.
DiffNode<L>	VariationDiff.getRoot()	Returns the root node of this tree.
DiffNode<L>	DiffNode.shallowCopy()
static <T extends VariationNode<T, L1>, L1 extends Label, L2 extends Label> DiffNode<L2>	DiffNode.unchanged(Function<? super T,DiffNode<L2>> convert, VariationNode<T,L1> variationNode)	Transforms a VariationNode into a DiffNode by diffing variationNode to itself.
static <T extends VariationNode<T, L>, L extends Label> DiffNode<L>	DiffNode.unchanged(VariationNode<T,L> variationNode)	Transforms a VariationNode into a DiffNode by diffing variationNode to itself.
static <T extends VariationNode<T, L>, L extends Label> DiffNode<L>	DiffNode.unchangedFlat(VariationNode<T,L> variationNode)	Transforms a VariationNode into a DiffNode by diffing variationNode to itself.

Methods in org.variantsync.diffdetective.variation.diff that return types with arguments of type DiffNode

Modifier and Type	Method	Description
List<DiffNode<L>>	VariationDiff.computeAllNodes()	Returns all nodes in this VariationDiff.
List<DiffNode<L>>	VariationDiff.computeAllNodesThat(Predicate<DiffNode<L>> property)	Returns all nodes that satisfy the given predicate.
List<DiffNode<L>>	VariationDiff.computeAnnotationNodes()	Returns all mapping nodes of this VariationDiff.
List<DiffNode<L>>	VariationDiff.computeArtifactNodes()	Returns all artifact nodes of this VariationDiff.
Iterable<DiffNode<L>>	DiffNode.getAllChildren()	Returns an efficient iterable representation of all direct children without duplicates.
Set<DiffNode<L>>	DiffNode.getAllChildrenSet()	Returns a new set with all children of this node without duplicates.
Stream<DiffNode<L>>	DiffNode.getAllChildrenStream()	Returns an efficient stream representation of all direct children without duplicates.
List<DiffNode<L>>	DiffNode.getChildOrder(Time time)	Returns the order of the children at time.
List<DiffNode<L>>	DiffNode.removeChildren(Time time)	Removes all children before or after the edit.

Methods in org.variantsync.diffdetective.variation.diff with parameters of type DiffNode

Modifier and Type	Method	Description
void	DiffNode.addBelow(DiffNode<L> newBeforeParent, DiffNode<L> newAfterParent)	Adds this subtree below the given parents.
void	DiffNode.addChild(DiffNode<L> child, Time time)	The same as insertChild(org.variantsync.diffdetective.variation.diff.DiffNode<L>, int, org.variantsync.diffdetective.variation.diff.Time) but puts the node at the end of the children list instead of inserting it at a specific index.
int	DiffNode.indexOfChild(DiffNode<L> child, Time time)	Returns the index of the given child in the list of children of this node.
void	DiffNode.insertChild(DiffNode<L> child, int index, Time time)	Insert child as child at the time time at the position index.
boolean	DiffNode.isChild(DiffNode<L> child)	Returns true iff this node is the before or after parent of the given node.
boolean	DiffNode.isChild(DiffNode<L> child, Time time)	Returns true iff this node is the parent of the given node at the given time.
boolean	DiffNode.isSameAs(DiffNode<L> other)	Returns true if this subtree is exactly equal to other.
private static <L extends Label> boolean	DiffNode.isSameAs(DiffNode<L> a, DiffNode<L> b, Set<DiffNode<L>> visited)
void	DiffNode.removeChild(DiffNode<L> child, Time time)	Removes the given node from this node's children before or after the edit.
void	VariationDiff.removeNode(DiffNode<L> node)	Removes the given node from the VariationDiff but keeps its children.
void	DiffNode.stealChildrenOf(DiffNode<L> other)	Removes all children from the given node and adds them as children to this node at the respective times.
boolean	VariationDiff.AllPathsEndAtRoot.test(DiffNode<?> d)	Returns true if all paths (in parent direction) starting at the given node end at the root.

Method parameters in org.variantsync.diffdetective.variation.diff with type arguments of type DiffNode

Modifier and Type	Method	Description
void	DiffNode.addChildren(Collection<DiffNode<L>> children, Time time)	Adds all given nodes at the time time as children using addChild(org.variantsync.diffdetective.variation.diff.DiffNode<L>, org.variantsync.diffdetective.variation.diff.Time).
boolean	VariationDiff.allMatch(Predicate<DiffNode<L>> condition)	Checks whether all nodes in this tree satisfy the given condition.
boolean	VariationDiff.anyMatch(Predicate<DiffNode<L>> condition)	Checks whether any node in this tree satisfies the given condition.
List<DiffNode<L>>	VariationDiff.computeAllNodesThat(Predicate<DiffNode<L>> property)	Returns all nodes that satisfy the given predicate.
int	VariationDiff.count(Predicate<DiffNode<L>> nodesToCount)	Returns the number of nodes in this tree that satisfy the given condition.
DiffNode<L>	DiffNode.deepCopy(HashMap<DiffNode<L>,DiffNode<L>> oldToNew)
DiffNode<L>	DiffNode.deepCopy(HashMap<DiffNode<L>,DiffNode<L>> oldToNew)
VariationDiff<L>	VariationDiff.forAll(Consumer<DiffNode<L>> procedure)	Invokes the given callback for each node in this VariationDiff.
static VariationDiff<DiffLinesLabel>	DiffGraph.fromNodes(Collection<DiffNode<DiffLinesLabel>> nodes)	Deprecated. Invokes DiffGraph.fromNodes(Collection, VariationDiffSource) )} with an unknown VariationDiffSource.
static VariationDiff<DiffLinesLabel>	DiffGraph.fromNodes(Collection<DiffNode<DiffLinesLabel>> nodes, VariationDiffSource source)	Deprecated. Takes a set of DiffNodes that forms a DiffGraph (i.e., similar to a VariationDiff but with no explicit root) and converts it to a VariationDiff by equipping it with a synthetic root node.
private static <L extends Label> boolean	DiffNode.isSameAs(DiffNode<L> a, DiffNode<L> b, Set<DiffNode<L>> visited)
boolean	VariationDiff.noneMatch(Predicate<DiffNode<L>> condition)	Checks whether no node in this tree satisfies the given condition.
void	DiffNode.removeChildren(Collection<DiffNode<L>> childrenToRemove)	Removes all given children for all times.
static <T extends VariationNode<T, L1>, L1 extends Label, L2 extends Label> DiffNode<L2>	DiffNode.unchanged(Function<? super T,DiffNode<L2>> convert, VariationNode<T,L1> variationNode)	Transforms a VariationNode into a DiffNode by diffing variationNode to itself.

Constructors in org.variantsync.diffdetective.variation.diff with parameters of type DiffNode

Modifier	Constructor	Description
private	AllPathsEndAtRoot(DiffNode<?> root)
(package private)	Projection(DiffNode<L> backingNode, Time time)	Creates a new projection of a DiffNode.
	VariationDiff(DiffNode<L> root)	Creates a VariationDiff that only consists of the single given root node.
	VariationDiff(DiffNode<L> root, VariationDiffSource source)	Creates a VariationDiff that only consists of the single given root node.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.bad

Fields in org.variantsync.diffdetective.variation.diff.bad with type parameters of type DiffNode

Modifier and Type	Field	Description
private final Map<DiffNode<L>,Map<Time,VariationTreeNode<L>>>	BadVDiff.FromGoodNodeTranslation.translate

Methods in org.variantsync.diffdetective.variation.diff.bad that return DiffNode

Modifier and Type	Method	Description
private DiffNode<L>	BadVDiff.mergeToGood(VariationTreeNode<L> before, VariationTreeNode<L> after)	Merges two VariationTreeNodes that represent the same node to a single unchanged DiffNode.
private DiffNode<L>	BadVDiff.toGood(VariationTreeNode<L> n)	Inverse of BadVDiff.fromGood(DiffNode, FromGoodNodeTranslation, Map, Map).

Methods in org.variantsync.diffdetective.variation.diff.bad with parameters of type DiffNode

Modifier and Type	Method	Description
private static <L extends Label> VariationTreeNode<L>	BadVDiff.fromGood(DiffNode<L> n, BadVDiff.FromGoodNodeTranslation<L> nodeTranslation, Map<VariationTreeNode<L>,DiffType> coloring, Map<VariationTreeNode<L>,DiffLineNumberRange> lines)	Performs a plain conversion of the given DiffNode n to a VariationTreeNode.
(package private) VariationTreeNode<L>	BadVDiff.FromGoodNodeTranslation.get(DiffNode<L> d, Time t)	Returns the VariationTreeNode that represents the given DiffNode d at the given time t in the produced bad diff.
private static <L extends Label> VariationTreeNode<L>	BadVDiff.plain(DiffNode<L> n)	Plain conversion of DiffNodes to VariationTree nodes.
(package private) void	BadVDiff.FromGoodNodeTranslation.put(DiffNode<L> d, Time t, VariationTreeNode<L> v)	Remember that the given DiffNode d was translated to the given VariationTreeNode v at time t.
(package private) void	BadVDiff.FromGoodNodeTranslation.put(DiffNode<L> d, VariationTreeNode<L> v)	Remember that the given DiffNode d was translated to the given VariationTreeNode v at all times d exists.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.construction

Methods in org.variantsync.diffdetective.variation.diff.construction that return DiffNode

Modifier and Type	Method	Description
static <B extends VariationNode<B, L>, L extends Label> DiffNode<L>	GumTreeDiff.diffUsingMatching(DiffNode<L> before, VariationNode<B,L> after, com.github.gumtreediff.matchers.Matcher matcher)	Create a DiffNode by matching nodes between before and after with matcher.
static <A extends VariationNode<A, L>, B extends VariationNode<B, L>, L extends Label> DiffNode<L>	GumTreeDiff.diffUsingMatching(VariationNode<A,L> before, VariationNode<B,L> after, com.github.gumtreediff.matchers.Matcher matcher)	Create a DiffNode by matching nodes between before and after with matcher.
static <L extends Label> DiffNode<L>	GumTreeDiff.improveMatching(DiffNode<L> tree, com.github.gumtreediff.matchers.Matcher matcher)	Run matcher on the matching extracted from tree and modify tree in-place to reflect the new matching.
private static <L extends Label> DiffNode<L>	GumTreeDiff.splitNode(DiffNode<L> beforeNode)	Removes the implicit matching between the BEFORE and AFTER projection of beforeNode.

Methods in org.variantsync.diffdetective.variation.diff.construction with parameters of type DiffNode

Modifier and Type	Method	Description
private static <L extends Label> void	GumTreeDiff.addUnmapped(com.github.gumtreediff.matchers.MappingStore mappings, DiffNode<L> parent, VariationTreeAdapter<L> afterNode)	Recursively adds afterNode to parent reusing matched nodes.
static <B extends VariationNode<B, L>, L extends Label> DiffNode<L>	GumTreeDiff.diffUsingMatching(DiffNode<L> before, VariationNode<B,L> after, com.github.gumtreediff.matchers.Matcher matcher)	Create a DiffNode by matching nodes between before and after with matcher.
static <L extends Label> DiffNode<L>	GumTreeDiff.improveMatching(DiffNode<L> tree, com.github.gumtreediff.matchers.Matcher matcher)	Run matcher on the matching extracted from tree and modify tree in-place to reflect the new matching.
private static <L extends Label> void	GumTreeDiff.joinNode(DiffNode<L> beforeNode, DiffNode<L> afterNode)	Merges afterNode into beforeNode such that beforeNode.isNon() == true.
private static <L extends Label> DiffNode<L>	GumTreeDiff.splitNode(DiffNode<L> beforeNode)	Removes the implicit matching between the BEFORE and AFTER projection of beforeNode.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.graph

Fields in org.variantsync.diffdetective.variation.diff.graph declared as DiffNode

Modifier and Type	Field	Description
private final DiffNode<L>	FormalDiffGraph.Edge.child	The field for the child record component.
private final DiffNode<L>	FormalDiffGraph.Edge.parent	The field for the parent record component.

Fields in org.variantsync.diffdetective.variation.diff.graph with type parameters of type DiffNode

Modifier and Type	Field	Description
private final Set<DiffNode<L>>	FormalDiffGraph.nodes	The field for the nodes record component.

Methods in org.variantsync.diffdetective.variation.diff.graph that return DiffNode

Modifier and Type	Method	Description
DiffNode<L>	FormalDiffGraph.Edge.child()	Returns the value of the child record component.
DiffNode<L>	FormalDiffGraph.Edge.parent()	Returns the value of the parent record component.

Methods in org.variantsync.diffdetective.variation.diff.graph that return types with arguments of type DiffNode

Modifier and Type	Method	Description
Set<DiffNode<L>>	FormalDiffGraph.nodes()	Returns the value of the nodes record component.

Constructors in org.variantsync.diffdetective.variation.diff.graph with parameters of type DiffNode

Modifier	Constructor	Description
	Edge(DiffNode<L> child, DiffNode<L> parent, Time time)	Creates an instance of a Edge record class.

Constructor parameters in org.variantsync.diffdetective.variation.diff.graph with type arguments of type DiffNode

Modifier	Constructor	Description
	FormalDiffGraph(Set<DiffNode<L>> nodes, Set<FormalDiffGraph.Edge<L>> edges)	Creates an instance of a FormalDiffGraph record class.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.parse

Fields in org.variantsync.diffdetective.variation.diff.parse declared as DiffNode

Modifier and Type	Field	Description
private DiffNode<DiffLinesLabel>	VariationDiffParser.lastArtifact	The last artifact node which was parsed by VariationDiffParser.parseLine(org.variantsync.diffdetective.variation.diff.parse.LogicalLine, org.variantsync.diffdetective.variation.diff.DiffType, org.variantsync.diffdetective.diff.text.DiffLineNumber).

Fields in org.variantsync.diffdetective.variation.diff.parse with type parameters of type DiffNode

Modifier and Type	Field	Description
private final Stack<DiffNode<DiffLinesLabel>>	VariationDiffParser.afterStack	A stack containing the current path after the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.
private final Stack<DiffNode<DiffLinesLabel>>	VariationDiffParser.beforeStack	A stack containing the current path before the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.

Methods in org.variantsync.diffdetective.variation.diff.parse with parameters of type DiffNode

Modifier and Type	Method	Description
private void	VariationDiffParser.addNode(DiffNode<DiffLinesLabel> newNode)	Adds a fully parsed node into the VariationDiff.

Method parameters in org.variantsync.diffdetective.variation.diff.parse with type arguments of type DiffNode

Modifier and Type	Method	Description
private void	VariationDiffParser.popIfChain(Stack<DiffNode<DiffLinesLabel>> stack, DiffLineNumber elseLineNumber)	Pop stack until an IF node is popped.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.serialize

Fields in org.variantsync.diffdetective.variation.diff.serialize declared as DiffNode

Modifier and Type	Field	Description
private final DiffNode<L>	StyledEdge.from	The field for the from record component.
private final DiffNode<L>	StyledEdge.to	The field for the to record component.

Methods in org.variantsync.diffdetective.variation.diff.serialize that return DiffNode

Modifier and Type	Method	Description
DiffNode<L>	StyledEdge.from()	Returns the value of the from record component.
DiffNode<L>	StyledEdge.to()	Returns the value of the to record component.

Methods in org.variantsync.diffdetective.variation.diff.serialize with parameters of type DiffNode

Modifier and Type	Method	Description
protected <La extends L> void	Format.sortedEdgeWithLabel(DiffNode<La> originalFrom, DiffNode<La> originalTo, StyledEdge.Style style, Consumer<StyledEdge<La>> callback)	Constructs a StyledEdge from originalFrom to originalTo.

Method parameters in org.variantsync.diffdetective.variation.diff.serialize with type arguments of type DiffNode

Modifier and Type	Method	Description
<La extends L> void	TikzExporter.exportVariationDiff(VariationDiff<La> variationDiff, Function<DiffNode<La>,Vec2> nodeLayout, OutputStream destination, boolean escape)
<La extends L> void	Format.forEachNode(VariationDiff<La> variationDiff, Consumer<DiffNode<La>> callback)	Iterates over all DiffNodes in variationDiff and calls callback.
private static VariationDiff<DiffLinesLabel>	LineGraphImport.parseVariationDiff(String lineGraph, Path inFile, List<DiffNode<DiffLinesLabel>> diffNodeList, LineGraphImportOptions<DiffLinesLabel> options)	Generates a VariationDiff from the given, already parsed parameters.

Constructors in org.variantsync.diffdetective.variation.diff.serialize with parameters of type DiffNode

Modifier	Constructor	Description
	StyledEdge(DiffNode<L> from, DiffNode<L> to, StyledEdge.Style style)	Creates an instance of a StyledEdge record class.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.serialize.edgeformat

Methods in org.variantsync.diffdetective.variation.diff.serialize.edgeformat with parameters of type DiffNode

Modifier and Type	Method	Description
protected <La extends L> void	EdgeLabelFormat.connectAccordingToLabel(DiffNode<La> child, DiffNode<La> parent, String edgeLabel)	Adds the given child node as the child of the given parent node for all times described by the given label (via addChild(DiffNode, Time)) In particular, this method checks if the given edge label starts with LineGraphConstants.BEFORE_PARENT, LineGraphConstants.AFTER_PARENT, or LineGraphConstants.BEFORE_AND_AFTER_PARENT and connects both nodes accordingly.

Method parameters in org.variantsync.diffdetective.variation.diff.serialize.edgeformat with type arguments of type DiffNode

Modifier and Type	Method	Description
<La extends L> void	EdgeLabelFormat.connect(String lineGraphLine, Map<Integer,DiffNode<La>> nodes)	Parses the edge in the given lineGraphLine.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.serialize.nodeformat

Methods in org.variantsync.diffdetective.variation.diff.serialize.nodeformat that return DiffNode

Modifier and Type	Method	Description
default DiffNode<DiffLinesLabel>	DiffNodeLabelFormat.fromLabelAndId(String lineGraphNodeLabel, int nodeId)	Converts a label of line graph into a DiffNode.

Methods in org.variantsync.diffdetective.variation.diff.serialize.nodeformat that return types with arguments of type DiffNode

Modifier and Type	Method	Description
default org.variantsync.functjonal.Pair<Integer,DiffNode<DiffLinesLabel>>	DiffNodeLabelFormat.fromLineGraphLine(String lineGraphLine)	Converts a line describing a graph (starting with "t # ") in line graph format into a VariationDiffSource.

Methods in org.variantsync.diffdetective.variation.diff.serialize.nodeformat with parameters of type DiffNode

Modifier and Type	Method	Description
static String	DiffNodeLabelPrettyfier.prettyPrintIfAnnotationOr(DiffNode<?> node, String elseValue)	Invokes DiffNodeLabelPrettyfier.prettyPrintTypeAndMapping(DiffNode) if the given node is an annotation, and returns the elseValue otherwise.
private static String	DiffNodeLabelPrettyfier.prettyPrintTypeAndMapping(DiffNode<?> node)	Auxiliary method for DiffNodeLabelPrettyfier.prettyPrintIfAnnotationOr(DiffNode, String).
String	DebugDiffNodeFormat.toLabel(DiffNode<? extends L> node)
String	DiffNodeLabelFormat.toLabel(DiffNode<? extends L> node)	Converts a DiffNode into a label suitable for exporting.
String	EditClassesDiffNodeFormat.toLabel(DiffNode<? extends L> node)
String	FormulasAndLineNumbersNodeFormat.toLabel(DiffNode<? extends L> node)
String	FullNodeFormat.toLabel(DiffNode<? extends DiffLinesLabel> node)
String	LabelOnlyDiffNodeFormat.toLabel(DiffNode<? extends L> node)
String	LineNumberFormat.toLabel(DiffNode<? extends L> node)
String	MappingsDiffNodeFormat.toLabel(DiffNode<? extends L> node)
String	PaperNodeFormat.toLabel(DiffNode<? extends L> node)
String	RenameRootNodeFormat.toLabel(DiffNode<? extends L> node)
String	ShowNodeFormat.toLabel(DiffNode<? extends L> node)
static <L extends Label> String	ShowNodeFormat.toLabel(DiffNode<L> node, Function<DiffNode<L>,String> artifactPrinter)
String	TypeDiffNodeFormat.toLabel(DiffNode<? extends L> node)
default List<String>	DiffNodeLabelFormat.toMultilineLabel(DiffNode<? extends L> node)	Converts a DiffNode into a multi line label suitable for exporting.
List<String>	FullNodeFormat.toMultilineLabel(DiffNode<? extends DiffLinesLabel> node)
List<String>	PaperNodeFormat.toMultilineLabel(DiffNode<? extends L> node)
List<String>	RenameRootNodeFormat.toMultilineLabel(DiffNode<? extends L> node)

Method parameters in org.variantsync.diffdetective.variation.diff.serialize.nodeformat with type arguments of type DiffNode

Modifier and Type	Method	Description
static <L extends Label> String	ShowNodeFormat.toLabel(DiffNode<L> node, Function<DiffNode<L>,String> artifactPrinter)

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.transform

Fields in org.variantsync.diffdetective.variation.diff.transform with type parameters of type DiffNode

Modifier and Type	Field	Description
private final List<Stack<DiffNode<DiffLinesLabel>>>	CollapseNestedNonEditedAnnotations.chainCandidates
private final List<Stack<DiffNode<DiffLinesLabel>>>	CollapseNestedNonEditedAnnotations.chains
private final Function<DiffNode<L>,L>	RelabelNodes.getLabel
private final Predicate<DiffNode<L>>	FeatureExpressionFilter.isFeatureAnnotation	Deprecated. The field for the isFeatureAnnotation record component.

Methods in org.variantsync.diffdetective.variation.diff.transform that return DiffNode

Modifier and Type	Method	Description
private static <L extends Label> DiffNode<L>	NaiveMovedArtifactDetection.findTwinOf(DiffNode<L> artifact, List<DiffNode<L>> artifactNodes)
private static <L extends Label> DiffNode<L>	NaiveMovedArtifactDetection.merge(DiffNode<L> added, DiffNode<L> removed)

Methods in org.variantsync.diffdetective.variation.diff.transform that return types with arguments of type DiffNode

Modifier and Type	Method	Description
private static <L extends Label> List<org.variantsync.functjonal.Pair<DiffNode<L>,DiffNode<L>>>	NaiveMovedArtifactDetection.findArtifactTwins(VariationDiff<L> variationDiff)
private static <L extends Label> List<org.variantsync.functjonal.Pair<DiffNode<L>,DiffNode<L>>>	NaiveMovedArtifactDetection.findArtifactTwins(VariationDiff<L> variationDiff)
Predicate<DiffNode<L>>	FeatureExpressionFilter.isFeatureAnnotation()	Deprecated. Returns the value of the isFeatureAnnotation record component.

Methods in org.variantsync.diffdetective.variation.diff.transform with parameters of type DiffNode

Modifier and Type	Method	Description
private static boolean	CollapseNestedNonEditedAnnotations.anyChildEdited(DiffNode<?> d)
private void	CollapseNestedNonEditedAnnotations.findChains(VariationDiffTraversal<DiffLinesLabel> traversal, DiffNode<DiffLinesLabel> subtree)
private static <L extends Label> DiffNode<L>	NaiveMovedArtifactDetection.findTwinOf(DiffNode<L> artifact, List<DiffNode<L>> artifactNodes)
private static boolean	CollapseNestedNonEditedAnnotations.hasExactlyOneChild(DiffNode<?> d)
private static boolean	CollapseNestedNonEditedAnnotations.inChainTail(DiffNode<?> d)
private static boolean	CollapseNestedNonEditedAnnotations.isEnd(DiffNode<?> d)
private static boolean	CollapseNestedNonEditedAnnotations.isHead(DiffNode<?> d)
private static <L extends Label> DiffNode<L>	NaiveMovedArtifactDetection.merge(DiffNode<L> added, DiffNode<L> removed)
private static boolean	CollapseNestedNonEditedAnnotations.noChildEdited(DiffNode<?> d)
void	CutNonEditedSubtrees.visit(VariationDiffTraversal<L> traversal, DiffNode<L> subtree)

Method parameters in org.variantsync.diffdetective.variation.diff.transform with type arguments of type DiffNode

Modifier and Type	Method	Description
private static void	CollapseNestedNonEditedAnnotations.collapseChain(Stack<DiffNode<DiffLinesLabel>> chain)
private void	CollapseNestedNonEditedAnnotations.finalize(Stack<DiffNode<DiffLinesLabel>> chain)
private static <L extends Label> DiffNode<L>	NaiveMovedArtifactDetection.findTwinOf(DiffNode<L> artifact, List<DiffNode<L>> artifactNodes)

Constructor parameters in org.variantsync.diffdetective.variation.diff.transform with type arguments of type DiffNode

Modifier	Constructor	Description
	FeatureExpressionFilter(Predicate<DiffNode<L>> isFeatureAnnotation)	Deprecated. Creates an instance of a FeatureExpressionFilter record class.
	RelabelNodes(Function<DiffNode<L>,L> newLabelOfNode)	Creates a new transformation that relables each node with the given function.

Uses of DiffNode in org.variantsync.diffdetective.variation.diff.traverse

Fields in org.variantsync.diffdetective.variation.diff.traverse with type parameters of type DiffNode

Modifier and Type	Field	Description
private final Set<DiffNode<L>>	VariationDiffTraversal.visited

Methods in org.variantsync.diffdetective.variation.diff.traverse with parameters of type DiffNode

Modifier and Type	Method	Description
private boolean	VariationDiffTraversal.markAsVisited(DiffNode<L> node)	Treat the given node as already visited regardless whether this is actually true or not.
void	VariationDiffTraversal.visit(DiffNode<L> subtree)	Start the traversal of a VariationDiff at the given DiffNode.
void	VariationDiffVisitor.visit(VariationDiffTraversal<L> traversal, DiffNode<L> subtree)	Invoked by a traversal when a node is visited.
void	VariationDiffTraversal.visitChildrenOf(DiffNode<L> subtree)	Continues the traversal by visiting all children of the given node sequentially.

Method parameters in org.variantsync.diffdetective.variation.diff.traverse with type arguments of type DiffNode

Modifier and Type	Method	Description
static <L extends Label> VariationDiffTraversal<L>	VariationDiffTraversal.forAll(Consumer<DiffNode<L>> procedure)	Creates a new traversal that will invoke the given callback once for each node in a visited VariationDiff.

Uses of DiffNode in org.variantsync.diffdetective.variation.tree

Method parameters in org.variantsync.diffdetective.variation.tree with type arguments of type DiffNode

Modifier and Type	Method	Description
VariationDiff<L>	VariationTree.toVariationDiff(Function<VariationTreeNode<L>,DiffNode<L>> nodeConverter)