Set<Set<HNode>> keySet = simpleHierarchyGraph.getCombineNodeSet();
for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
Set<HNode> combineSet = (Set<HNode>) iterator.next();
- System.out.println("--combineSet=" + combineSet);
HNode combinationNode = getCombinationNode(combineSet);
- System.out.println("--combinationNode=" + combinationNode + " combineSet=" + combineSet);
-
- System.out.println("--hierarchynodes="
+ System.out.println("\n@INSERT COMBINATION NODE FOR combineSet=" + combineSet
+ + " --combinationNode=" + combinationNode);
+ System.out.println(" --hierarchynodes="
+ simpleHierarchyGraph.getCombinationNodeSetByCombineNodeSet(combineSet));
Set<HNode> simpleHNodeSet =
if (isFirstNodeOfChain) {
simpleHierarchyGraph.addFirstNodeOfChain(combineSet, simpleHNode);
System.out.println("IT IS THE FIRST NODE OF THE CHAIN:" + simpleHNode);
+ // System.out.println("--->INCOMING NODES=");
+ // Set<HNode> inNodeSet = simpleHierarchyGraph.getIncomingNodeSet(simpleHNode);
+ // for (Iterator iterator3 = inNodeSet.iterator(); iterator3.hasNext();) {
+ // HNode inNode = (HNode) iterator3.next();
+ // System.out.println(" inNode=" + inNode + " combineSet="
+ // + simpleHierarchyGraph.getCombineSetByCombinationNode(inNode) + " SKELETON TO SET="
+ // + simpleHierarchyGraph.getSkeleteNodeSetReachTo(inNode));
+ // }
}
}
srcNode = getHNode(inSkeletonNode.getDescriptor());
}
// System.out.println("--srcNode=" + srcNode);
+ System.out.println(" ADD EDGE SRC=" + srcNode + " -> " + combinationNode);
addEdgeWithNoCycleCheck(srcNode, combinationNode);
}
}
+ public Set<HNode> getSkeleteNodeSetReachToNoTransitive(HNode node) {
+
+ Set<HNode> reachToSet = new HashSet<HNode>();
+ Set<HNode> visited = new HashSet<HNode>();
+ // visited.add(node);
+ recurSkeletonReachTo(node, reachToSet, visited);
+
+ // obsolete!
+ // if a node reaches to one of elements in the reachToSet, we do not need to keep it
+ // because the node is not directly connected to the combination node
+ // removeRedundantReachToNodes(reachToSet);
+
+ return removeTransitivelyReachToSet(reachToSet);
+ // return reachToSet;
+ }
+
public Set<HNode> getSkeleteNodeSetReachTo(HNode node) {
Set<HNode> reachToSet = new HashSet<HNode>();
// because the node is not directly connected to the combination node
// removeRedundantReachToNodes(reachToSet);
- return reachToSet;
+ // TODO
+ return removeTransitivelyReachToSet(reachToSet);
+ // return reachToSet;
}
private void recurSkeletonReachTo(HNode node, Set<HNode> reachToSet, Set<HNode> visited) {
if (!node.isSkeleton()) {
Set<HNode> reachToSet = getSkeleteNodeSetReachTo(node);
// Set<HNode> tempSet = removeTransitivelyReachToSet(reachToSet);
+ // System.out.println("ALL REACH SET=" + reachToSet);
// reachToSet = removeTransitivelyReachToSet(reachToSet);
Set<HNode> curReachToSet = new HashSet<HNode>();
curReachToSet.add(getCurrentHNode(reachSkeletonNode));
}
- System.out.println("-curReachToSet=" + curReachToSet + " reachToSet=" + reachToSet);
+ // System.out.println("-curReachToSett=" + curReachToSet + " reachToSet=" + reachToSet);
reachToSet = curReachToSet;
// System.out.println("$node=" + node + " reachToNodeSet=" + reachToSet + " tempSet="
return max;
}
- public Stack<String> computeDistance(HNode startNode, Set<HNode> endNodeSet, Set<HNode> combineSet) {
- System.out.println("#####computeDistance startNode=" + startNode + " endNode=" + endNodeSet);
+ public Stack<String> computeDistance2(HNode startNode, Set<HNode> endNodeSet,
+ HierarchyGraph scGraph, Set<HNode> combineSet) {
+ System.out
+ .println("#####computeDistanceance startNode=" + startNode + " endNode=" + endNodeSet);
+ Stack<String> trace = new Stack<String>();
+ return recur_computeDistance2(startNode, endNodeSet, scGraph, 0, combineSet, trace);
+ }
+
+ public Stack<String> computeDistance(HNode startNode, Set<HNode> endNodeSet,
+ HierarchyGraph scGraph, Set<HNode> combineSet) {
+ System.out
+ .println("#####computeDistanceance startNode=" + startNode + " endNode=" + endNodeSet);
Stack<String> trace = new Stack<String>();
return recur_computeDistance(startNode, endNodeSet, 0, combineSet, trace);
}
}
}
-
if (endNodeSet.contains(curNode)) {
// it reaches to one of endNodeSet
return trace;
}
}
- System.out.println(" traverse more to" + inNode + " before-trace=" + trace);
+ // System.out.println(" traverse more to" + inNode + " before-trace=" + trace);
Stack<String> newTrace = (Stack<String>) trace.clone();
Stack<String> curTrace =
recur_computeDistance(inNode, endNodeSet, count, combineSet, newTrace);
- System.out.println("curTrace=" + curTrace);
+ // System.out.println("curTracerTrace=" + curTrace);
if (curTrace != null && curTrace.size() > curMaxDistance) {
curMaxTrace = curTrace;
}
}
return curMaxTrace;
+
}
- private int recur_computeDistance2(HNode startNode, HNode curNode, Set<HNode> endNodeSet,
- int count, Set<HNode> combineSet) {
+ private Stack<String> recur_computeDistance2(HNode curNode, Set<HNode> endNodeSet,
+ HierarchyGraph scGraph, int count, Set<HNode> combineSet, Stack<String> trace) {
- if (!curNode.equals(startNode)) {
- // do not count the start node
- count++;
+ if (!curNode.isSkeleton()) {
+ if (curNode.isSharedNode()) {
+ trace.add("S");
+ } else {
+ trace.add("N");
+ }
}
- if (endNodeSet.contains(curNode)) {
+ System.out.println(" curNode=" + curNode + " curTrace=" + trace);
+ // System.out.println(" curNode=" + curNode + " curSCNode="
+ // + scGraph.getCurrentHNode(curNode) + " contains="
+ // + endNodeSet.contains(scGraph.getCurrentHNode(curNode)));
+ if (endNodeSet.contains(scGraph.getCurrentHNode(curNode))) {
// it reaches to one of endNodeSet
- return count;
+ return trace;
}
Set<HNode> inNodeSet = getIncomingNodeSet(curNode);
int curMaxDistance = 0;
+ Stack<String> curMaxTrace = (Stack<String>) trace.clone();
+ ;
for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
HNode inNode = (HNode) iterator.next();
// traverse more...
}
}
- System.out.println(" traverse more to" + inNode + " before-count=" + count);
- int dist = recur_computeDistance2(startNode, inNode, endNodeSet, count, combineSet);
- if (dist > curMaxDistance) {
- curMaxDistance = dist;
- }
- }
- return curMaxDistance;
- }
-
- public int computeDistance2(HNode startNode, Set<HNode> endNodeSet, Set<HNode> combineSet) {
- System.out.println("#####computeDistance startNode=" + startNode + " endNode=" + endNodeSet);
- return recur_computeDistance2(startNode, startNode, endNodeSet, 0, 0, combineSet);
- }
-
- private int recur_computeDistance2(HNode startNode, HNode curNode, Set<HNode> endNodeSet,
- int sharedCount, int nonSharedCount, Set<HNode> combineSet) {
+ // Stack<String> newTrace = (Stack<String>) trace.clone();
+ // Stack<String> curTrace =
+ // recur_computeDistance(inNode, endNodeSet, scGraph, count, combineSet, newTrace);
+ // if (curTrace != null) {
+ // return curTrace;
+ // }
- if (!curNode.equals(startNode)) {
- // do not count the start node
- if (curNode.isSharedNode()) {
- sharedCount++;
- } else {
- nonSharedCount++;
+ Set<HNode> inReachToNodeSet = getSkeleteNodeSetReachToNoTransitive(inNode);
+ Set<HNode> inCurReachToNodeSet = new HashSet<HNode>();
+ for (Iterator iterator2 = inReachToNodeSet.iterator(); iterator2.hasNext();) {
+ HNode aboveNode = (HNode) iterator2.next();
+ inCurReachToNodeSet.add(getCurrentHNode(aboveNode));
}
- }
- if (endNodeSet.contains(curNode)) {
- // it reaches to one of endNodeSet
- if (sharedCount > nonSharedCount) {
- return sharedCount;
- } else {
- return nonSharedCount;
- }
- }
+ if (combineSet != null || inCurReachToNodeSet.equals(endNodeSet)) {
+ System.out
+ .println(" traverse to incomingNode=" + inNode + " before-trace=" + trace);
- Set<HNode> inNodeSet = getIncomingNodeSet(curNode);
+ Stack<String> newTrace = (Stack<String>) trace.clone();
+ Stack<String> curTrace =
+ recur_computeDistance2(inNode, endNodeSet, scGraph, count, combineSet, newTrace);
- int curMaxDistance = 0;
- for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
- HNode inNode = (HNode) iterator.next();
- // traverse more...
-
- if (inNode.isCombinationNode() && combineSet != null) {
- // check if inNode have the same combination set of the starting node
- Set<HNode> inNodeCombineSet = getCombineSetByCombinationNode(inNode);
- if (!inNodeCombineSet.equals(combineSet)) {
- continue;
+ if (curTrace != null && curTrace.size() > curMaxDistance) {
+ curMaxTrace = curTrace;
+ curMaxDistance = curTrace.size();
}
+ } else {
+ System.out.println("NOT TRAVERSE a new inNode=" + inNode + " inReachToNodeSet="
+ + inCurReachToNodeSet);
}
- System.out.println(" traverse more to" + inNode + " sC=" + sharedCount + " nC="
- + nonSharedCount);
- int dist =
- recur_computeDistance2(startNode, inNode, endNodeSet, sharedCount, nonSharedCount,
- combineSet);
- if (dist > curMaxDistance) {
- curMaxDistance = dist;
- }
}
- return curMaxDistance;
+ return curMaxTrace;
}
public int countNonSharedNode(HNode startNode, Set<HNode> endNodeSet) {
// HNode inNode = inNodeSet.iterator().next();
return -1;
}
+
+ public void removeIsolatedNodes() {
+ Set<HNode> toberemoved = new HashSet<HNode>();
+ for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
+ HNode node = (HNode) iterator.next();
+ if (getIncomingNodeSet(node).isEmpty() && getOutgoingNodeSet(node).isEmpty()) {
+ toberemoved.add(node);
+ }
+ }
+ nodeSet.removeAll(toberemoved);
+ }
}