public void mergeIn(SPQRTreeNode tn2) {
addChildNodes(tn2.getChildNodes());
persistentGraphEdges.addAll(tn2.getPersistentGraphEdges());
nodeType = SPQRNodeType.none;
skeletonEdges = null;
referenceEdge = null;
}
private String toStringHelper(SPQRTreeNode tn, int depth) {
String result = "";
for (int i = 0; i < depth; i++) {
result += "\t";
}
result += tn.toString();
result += "\n";
for (SPQRTreeNode c : tn.getChildNodes()) {
result += toStringHelper(c, depth + 1);
}
return result;
}
private void orderSNodes(SPQRTreeNode toOrder) {
// If the node if a sequence.
if (toOrder.getNodeType() == SPQRNodeType.snode) {
Vector<SPQRTreeNode> reorderedChildren = new Vector<SPQRTreeNode>();
// Remove the reference edge from the sequence.
MultiSet<Pair<Integer, Integer>> sEdgesMinReference =
new MultiSet<Pair<Integer, Integer>>(toOrder.getSkeletonEdges());
sEdgesMinReference.remove(toOrder.getReferenceEdge());
// The start of the sequence is one of the nodes of the reference edge.
Integer startNode = Pair.get1(toOrder.getReferenceEdge());
Integer endNode = nextNode(startNode, sEdgesMinReference);
// Iterate over all edges in the sequence.
do {
// Find the child that contains both the start and the end node of the edgeToWorkWith.
SPQRTreeNode containingChild = null;
for (SPQRTreeNode c : toOrder.getChildNodes()) {
boolean containsN1 = false;
boolean containsN2 = false;
for (Pair<Integer, Integer> e : c.getPersistentGraphEdges()) {
containsN1 =
containsN1 || (Pair.get1(e).equals(startNode)) || (Pair.get2(e).equals(startNode));
containsN2 =
containsN2 || (Pair.get1(e).equals(endNode)) || (Pair.get2(e).equals(endNode));
}
if (containsN1 && containsN2) {
containingChild = c;
}
}
// That child is the next child in the sequence.
reorderedChildren.add(containingChild);
startNode = endNode;
endNode = nextNode(endNode, sEdgesMinReference);
} while (endNode != null);
toOrder.setChildNodes(reorderedChildren);
}
for (SPQRTreeNode c : toOrder.getChildNodes()) {
orderSNodes(c);
}
}
private void addSPQRTreeNodeAndChildren(
int spqrTreePointer, int spqrTreeNodePointer, SPQRTreeNode toNode) {
treeNode2TreeNodePtr.put(toNode, spqrTreeNodePointer);
switch (this.spqrNodeType(spqrTreePointer, spqrTreeNodePointer)) {
case 0:
toNode.setNodeType(SPQRNodeType.snode);
break;
case 1:
toNode.setNodeType(SPQRNodeType.pnode);
break;
case 2:
toNode.setNodeType(SPQRNodeType.rnode);
break;
}
int pgPointer = spqrPertinentGraph(spqrTreePointer, spqrTreeNodePointer);
for (Integer ePtr : spqrPertinentEdges(pgPointer)) {
int orgNodes[] = this.spqrPertinentEdgeOriginalNodes(pgPointer, ePtr);
toNode.addPersistentGraphEdge(
nodePointer2NodeId.get(orgNodes[0]), nodePointer2NodeId.get(orgNodes[1]));
}
int sgPointer = spqrSkeleton(spqrTreePointer, spqrTreeNodePointer);
for (Integer ePtr : spqrSkeletonEdges(sgPointer)) {
int orgNodes[] = this.spqrSkeletonEdgeOriginalNodes(sgPointer, ePtr);
toNode.addSkeletonEdge(
nodePointer2NodeId.get(orgNodes[0]), nodePointer2NodeId.get(orgNodes[1]));
if (!spqrSkeletonEdgeIsVirtual(sgPointer, ePtr)) {
SPQRTreeNode childForRealEdge = toNode.addChildNode();
childForRealEdge.setNodeType(SPQRNodeType.qnode);
childForRealEdge.addSkeletonEdge(
nodePointer2NodeId.get(orgNodes[0]), nodePointer2NodeId.get(orgNodes[1]));
childForRealEdge.addPersistentGraphEdge(
nodePointer2NodeId.get(orgNodes[0]), nodePointer2NodeId.get(orgNodes[1]));
}
}
int sRefEdge = this.spqrPertinentSkeletonReferenceEdge(pgPointer);
int orgNodes[] = this.spqrSkeletonEdgeOriginalNodes(sgPointer, sRefEdge);
toNode.setReferenceEdge(
nodePointer2NodeId.get(orgNodes[0]), nodePointer2NodeId.get(orgNodes[1]));
toNode.referenceEdgeIsVirtual(spqrSkeletonEdgeIsVirtual(sgPointer, sRefEdge));
int spqrParentPointer = 0;
if (toNode.getParentNode() != null) {
spqrParentPointer = treeNode2TreeNodePtr.get(toNode.getParentNode());
}
for (int childPtr : spqrChildNodes(spqrTreePointer, spqrTreeNodePointer, spqrParentPointer)) {
SPQRTreeNode newChild = toNode.addChildNode();
addSPQRTreeNodeAndChildren(spqrTreePointer, childPtr, newChild);
}
}
public void setChildNodes(Vector<SPQRTreeNode> ns) {
childNodes = ns;
for (SPQRTreeNode n : ns) {
n.setParentNode(this);
}
}
public void addChildNodes(Vector<SPQRTreeNode> ns) {
childNodes.addAll(ns);
for (SPQRTreeNode n : ns) {
n.setParentNode(this);
}
}
public SPQRTreeNode addChildNode() {
SPQRTreeNode s = new SPQRTreeNode();
s.setParentNode(this);
childNodes.add(s);
return s;
}
public void addChildNode(SPQRTreeNode n) {
n.setParentNode(this);
childNodes.add(n);
}
