changes.

[IRC.git] / Robust / src / Analysis / SSJava / HierarchyGraph.java

diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java
index 4e7c4b57a6a52e3e6e8c7680d70095be7b49a240..13264cf194c37ee6236ebef3a9944cd564160a97 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -1397,6 +1397,48 @@ public class HierarchyGraph {
     return max;
   }
 
+  public int computeDistance(HNode startNode, Set<HNode> endNodeSet) {
+    System.out.println("#####computeDistance startNode=" + startNode + " endNode=" + endNodeSet);
+    return recur_computeDistance(startNode, startNode, endNodeSet, 0, 0);
+  }
+
+  private int recur_computeDistance(HNode startNode, HNode curNode, Set<HNode> endNodeSet,
+      int sharedCount, int nonSharedCount) {
+
+    if (!curNode.equals(startNode)) {
+      // do not count the start node
+      if (curNode.isSharedNode()) {
+        sharedCount++;
+      } else {
+        nonSharedCount++;
+      }
+    }
+
+    if (endNodeSet.contains(curNode)) {
+      // it reaches to one of endNodeSet
+      if (sharedCount > nonSharedCount) {
+        return sharedCount;
+      } else {
+        return nonSharedCount;
+      }
+    }
+
+    Set<HNode> inNodeSet = getIncomingNodeSet(curNode);
+
+    int curMaxDistance = 0;
+    for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
+      HNode inNode = (HNode) iterator.next();
+      // traverse more...
+      System.out.println("    traverse more to" + inNode + "  sC=" + sharedCount + " nC="
+          + nonSharedCount);
+      int dist = recur_computeDistance(startNode, inNode, endNodeSet, sharedCount, nonSharedCount);
+      if (dist > curMaxDistance) {
+        curMaxDistance = dist;
+      }
+    }
+    return curMaxDistance;
+  }
+
   public int countNonSharedNode(HNode startNode, Set<HNode> endNodeSet) {
     System.out.println("countNonSharedNode startNode=" + startNode + " endNode=" + endNodeSet);
     return recur_countNonSharedNode(startNode, endNodeSet, 0);
@@ -1406,6 +1448,31 @@ public class HierarchyGraph {
 
     Set<HNode> inNodeSet = getIncomingNodeSet(startNode);
 
+    for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
+      HNode inNode = (HNode) iterator.next();
+      if (endNodeSet.contains(inNode)) {
+        count++;
+        return count;
+      } else {
+        if (!inNode.isSharedNode()) {
+          count++;
+        }
+        return recur_countNonSharedNode2(inNode, endNodeSet, count);
+      }
+    }
+
+    return 0;
+  }
+
+  public int countNonSharedNode2(HNode startNode, Set<HNode> endNodeSet) {
+    System.out.println("countNonSharedNode startNode=" + startNode + " endNode=" + endNodeSet);
+    return recur_countNonSharedNode2(startNode, endNodeSet, 0);
+  }
+
+  private int recur_countNonSharedNode2(HNode startNode, Set<HNode> endNodeSet, int count) {
+
+    Set<HNode> inNodeSet = getIncomingNodeSet(startNode);
+
     if (inNodeSet.size() == 0) {
       // it is directly connected to the TOP node
     }
@@ -1418,7 +1485,7 @@ public class HierarchyGraph {
         if (!inNode.isSharedNode()) {
           count++;
         }
-        return recur_countNonSharedNode(inNode, endNodeSet, count);
+        return recur_countNonSharedNode2(inNode, endNodeSet, count);
       }
     }