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 720be2dc4cc1baac827a43836f9a68aad3f7ba18..09519c837f5ce09afe3938e6e99ecf596a725edc 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -141,10 +141,13 @@ public class HierarchyGraph {
     if (possibleCycleSet.size() > 0) {
 
       if (possibleCycleSet.size() == 1) {
+        System.out.println("possibleCycleSet=" + possibleCycleSet + "  from src=" + srcHNode
+            + " dstHNode=" + dstHNode);
         if (dstHNode.isSharedNode()) {
           // it has already been assigned shared node.
         } else {
           dstHNode.setSharedNode(true);
+          System.out.println("$$$setShared=" + dstHNode);
         }
         return;
       }
@@ -249,6 +252,7 @@ public class HierarchyGraph {
     skeletonGraph.setMapHNodeToDescSet(getMapHNodeToDescSet());
     skeletonGraph.setMapHNodetoMergeSet(getMapHNodetoMergeSet());
     skeletonGraph.setMapHNodeToCurrentHNode(getMapHNodeToCurrentHNode());
+    skeletonGraph.setMapHNodeNameToCurrentHNode(getMapHNodeNameToCurrentHNode());
 
     return skeletonGraph;
 
@@ -398,7 +402,7 @@ public class HierarchyGraph {
   private void addEdgeWithNoCycleCheck(HNode srcHNode, HNode dstHNode) {
     getIncomingNodeSet(dstHNode).add(srcHNode);
     getOutgoingNodeSet(srcHNode).add(dstHNode);
-    System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
+    // System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
   }
 
   private HNode mergeNodes(Set<HNode> set, boolean onlyCombinationNodes) {
@@ -499,6 +503,7 @@ public class HierarchyGraph {
   }
 
   private void addMapHNodeToCurrentHNode(HNode curNode, HNode newNode) {
+
     if (curNode.isMergeNode()) {
       Set<HNode> mergingSet = getMergingSet(curNode);
       mergingSet.add(curNode);
@@ -513,6 +518,7 @@ public class HierarchyGraph {
       mapHNodeToCurrentHNode.put(curNode, newNode);
       mapHNodeNameToCurrentHNode.put(curNode.getName(), newNode);
     }
+
   }
 
   public HNode getCurrentHNode(HNode node) {
@@ -774,9 +780,12 @@ public class HierarchyGraph {
     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);
+      // System.out.println("--combineSet=" + combineSet);
       HNode combinationNode = getCombinationNode(combineSet);
-      System.out.println("--combinationNode=" + combinationNode);
+      System.out.println("--combinationNode=" + combinationNode + "   combineSet=" + combineSet);
+
+      System.out.println("--hierarchynodes="
+          + simpleHierarchyGraph.getCombinationNodeSetByCombineNodeSet(combineSet));
       // add an edge from a skeleton node to a combination node
       for (Iterator iterator2 = combineSet.iterator(); iterator2.hasNext();) {
         HNode inSkeletonNode = (HNode) iterator2.next();
@@ -845,12 +854,13 @@ public class HierarchyGraph {
 
     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);
+    // removeRedundantReachToNodes(reachToSet);
 
     return reachToSet;
   }
@@ -879,6 +889,7 @@ public class HierarchyGraph {
       HNode inNode = (HNode) iterator.next();
 
       if (inNode.isSkeleton()) {
+        visited.add(inNode);
         reachToSet.add(inNode);
       } else if (!visited.contains(inNode)) {
         visited.add(inNode);
@@ -964,6 +975,11 @@ public class HierarchyGraph {
       HNode node = (HNode) iterator.next();
       if (!node.isSkeleton()) {
         Set<HNode> reachToSet = getSkeleteNodeSetReachTo(node);
+        // Set<HNode> tempSet = removeTransitivelyReachToSet(reachToSet);
+        // reachToSet = removeTransitivelyReachToSet(reachToSet);
+        Set<HNode> tempSet = reachToSet;
+        System.out.println("$node=" + node + "   reachToNodeSet=" + reachToSet + " tempSet="
+            + tempSet);
         if (reachToSet.size() > 1) {
           // if (countSkeletonNodes(reachToSet) > 1) {
           System.out.println("-node=" + node + "  reachToSet=" + reachToSet);
@@ -986,6 +1002,38 @@ public class HierarchyGraph {
 
   }
 
+  private Set<HNode> removeTransitivelyReachToSet(Set<HNode> reachToSet) {
+
+    Set<HNode> toberemoved = new HashSet<HNode>();
+    Set<HNode> visited = new HashSet<HNode>();
+    for (Iterator iterator = reachToSet.iterator(); iterator.hasNext();) {
+      HNode node = (HNode) iterator.next();
+      visited.add(node);
+      recurIsReachingTo(node, reachToSet, toberemoved, visited);
+    }
+
+    Set<HNode> rSet = new HashSet<HNode>();
+    rSet.addAll(reachToSet);
+    rSet.removeAll(toberemoved);
+    return rSet;
+  }
+
+  private void recurIsReachingTo(HNode curNode, Set<HNode> reachToSet, Set<HNode> toberemoved,
+      Set<HNode> visited) {
+    Set<HNode> inNodeSet = getIncomingNodeSet(curNode);
+
+    for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
+      HNode inNode = (HNode) iterator.next();
+      if (reachToSet.contains(inNode)) {
+        toberemoved.add(inNode);
+      } else if (!visited.contains(inNode)) {
+        visited.add(inNode);
+        recurIsReachingTo(inNode, reachToSet, toberemoved, visited);
+      }
+    }
+
+  }
+
   public Map<HNode, Set<HNode>> getMapCombinationNodeToCombineNodeSet() {
     return mapCombinationNodeToCombineNodeSet;
   }
@@ -1071,7 +1119,7 @@ public class HierarchyGraph {
 
   public void assignUniqueIndexToNode() {
     int idx = 1;
-    System.out.println("nodeSet=" + nodeSet);
+    // System.out.println("nodeSet=" + nodeSet);
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
       mapHNodeToUniqueIndex.put(node, idx);
@@ -1101,17 +1149,17 @@ public class HierarchyGraph {
       basis.addAll(BASISTOPELEMENT);
 
       Set<HNode> reachableNodeSet = getReachableNodeSetFrom(node);
-      System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
-      System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
+      // System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
+      // System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
       // if a node is reachable from the current node
       // need to remove the index of the reachable node from the basis
 
       basis.remove(getHNodeIndex(node));
       for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
         HNode reachableNode = (HNode) iterator2.next();
-        System.out.println("reachableNode=" + reachableNode);
-        System.out.println("getHNodeIndex(reachableNode))="
-            + mapHNodeToUniqueIndex.get(reachableNode));
+        // System.out.println("reachableNode=" + reachableNode);
+        // System.out.println("getHNodeIndex(reachableNode))="
+        // + mapHNodeToUniqueIndex.get(reachableNode));
         int idx = getHNodeIndex(reachableNode);
         basis.remove(idx);
       }
@@ -1162,10 +1210,21 @@ public class HierarchyGraph {
   }
 
   public void writeGraph() {
+    writeGraph(false);
+  }
+
+  public void writeGraph(boolean isSimple) {
 
     String graphName = "hierarchy" + name;
+    System.out.println("#GRAPHNAME=" + graphName);
     graphName = graphName.replaceAll("[\\W]", "");
 
+    if (isSimple) {
+      graphName += "_PAPER";
+    }
+
+    // System.out.println("***graphName=" + graphName + "   node siz=" + nodeSet.size());
+
     try {
       BufferedWriter bw = new BufferedWriter(new FileWriter(graphName + ".dot"));
 
@@ -1182,18 +1241,30 @@ public class HierarchyGraph {
 
         if (outSet.size() == 0) {
           if (!addedNodeSet.contains(u)) {
-            drawNode(bw, u);
+            if (!isSimple) {
+              drawNode(bw, u);
+            } else {
+              drawNodeName(bw, u);
+            }
             addedNodeSet.add(u);
           }
         } else {
           for (Iterator iterator = outSet.iterator(); iterator.hasNext();) {
             HNode v = (HNode) iterator.next();
             if (!addedNodeSet.contains(u)) {
-              drawNode(bw, u);
+              if (!isSimple) {
+                drawNode(bw, u);
+              } else {
+                drawNodeName(bw, u);
+              }
               addedNodeSet.add(u);
             }
             if (!addedNodeSet.contains(v)) {
-              drawNode(bw, v);
+              if (!isSimple) {
+                drawNode(bw, v);
+              } else {
+                drawNodeName(bw, v);
+              }
               addedNodeSet.add(v);
             }
             bw.write("" + u.getName() + " -> " + v.getName() + ";\n");
@@ -1231,11 +1302,17 @@ public class HierarchyGraph {
     return str;
   }
 
+  private void drawNodeName(BufferedWriter bw, HNode node) throws IOException {
+    String nodeName = node.getNamePropertyString();
+    bw.write(node.getName() + " [label=\"" + nodeName + "\"]" + ";\n");
+  }
+
   private void drawNode(BufferedWriter bw, HNode node) throws IOException {
     String nodeName;
     if (node.isMergeNode()) {
       nodeName = node.getNamePropertyString();
       Set<HNode> mergeSet = mapMergeNodetoMergingSet.get(node);
+      System.out.println("node=" + node + "   mergeSet=" + mergeSet);
       nodeName += ":" + convertMergeSetToString(mergeSet);
     } else {
       nodeName = node.getNamePropertyString();