Robust/src/Analysis/OoOJava/SESELock.java

   1 package Analysis.OoOJava;
   2
   3 import java.util.HashMap;
   4 import java.util.HashSet;
   5 import java.util.Iterator;
   6 import java.util.Set;
   7
   8 public class SESELock {
   9
  10   private HashSet<ConflictNode> conflictNodeSet;
  11   private HashSet<ConflictEdge> conflictEdgeSet;
  12   private HashMap<ConflictNode, Integer> nodeTypeMap;
  13   private int id;
  14
  15   public SESELock() {
  16     conflictNodeSet = new HashSet<ConflictNode>();
  17     conflictEdgeSet = new HashSet<ConflictEdge>();
  18     nodeTypeMap = new HashMap<ConflictNode, Integer>();
  19   }
  20
  21   public void addConflictNode(ConflictNode node, int type) {
  22     conflictNodeSet.add(node);
  23     setNodeType(node, type);
  24   }
  25
  26   public void setNodeType(ConflictNode node, int type) {
  27     nodeTypeMap.put(node, new Integer(type));
  28   }
  29
  30   public int getNodeType(ConflictNode node) {
  31     return nodeTypeMap.get(node).intValue();
  32   }
  33
  34   public void addConflictEdge(ConflictEdge e) {
  35     conflictEdgeSet.add(e);
  36   }
  37
  38   public boolean containsConflictEdge(ConflictEdge e) {
  39     return conflictEdgeSet.contains(e);
  40   }
  41
  42   public HashSet<ConflictNode> getConflictNodeSet() {
  43     return conflictNodeSet;
  44   }
  45
  46   public boolean isWriteNode(ConflictNode node) {
  47     if (node.getWriteEffectSet().isEmpty()) {
  48       return false;
  49     } else {
  50       return true;
  51     }
  52   }
  53
  54   public boolean hasSelfCoarseEdge(ConflictNode node) {
  55
  56     Set<ConflictEdge> set = node.getEdgeSet();
  57     for (Iterator iterator = set.iterator(); iterator.hasNext();) {
  58       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
  59
  60       if (conflictEdge.isCoarseEdge() && conflictEdge.getVertexU() == conflictEdge.getVertexV()) {
  61         return true;
  62       }
  63     }
  64     return false;
  65   }
  66
  67   public ConflictNode getNewNodeConnectedWithGroup(ConflictEdge newEdge) {
  68
  69     // check whether or not the new node has a fine-grained edges to all
  70     // current nodes.
  71
  72     ConflictNode newNode;
  73     if (conflictNodeSet.contains(newEdge.getVertexU())) {
  74       newNode = newEdge.getVertexV();
  75     } else if (conflictNodeSet.contains(newEdge.getVertexV())) {
  76       newNode = newEdge.getVertexU();
  77     } else {
  78       return null;
  79     }
  80
  81     int count = 0;
  82     Set<ConflictEdge> edgeSet = newNode.getEdgeSet();
  83     for (Iterator iterator = edgeSet.iterator(); iterator.hasNext();) {
  84       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
  85       if (!conflictEdge.getVertexU().equals(newNode)
  86           && conflictNodeSet.contains(conflictEdge.getVertexU())) {
  87         count++;
  88       } else if (!conflictEdge.getVertexV().equals(newNode)
  89           && conflictNodeSet.contains(conflictEdge.getVertexV())) {
  90         count++;
  91       }
  92     }
  93
  94     if (count == conflictNodeSet.size()) {
  95       // connected to all current nodes in group
  96       return newNode;
  97     }
  98
  99     return null;
 100
 101   }
 102
 103   public void addEdge(ConflictEdge edge) {
 104     conflictNodeSet.add(edge.getVertexU());
 105     conflictNodeSet.add(edge.getVertexV());
 106   }
 107
 108   public int getID() {
 109     return id;
 110   }
 111
 112   public void setID(int id) {
 113     this.id = id;
 114   }
 115
 116   public boolean containsConflictNode(ConflictNode node) {
 117
 118     return conflictNodeSet.contains(node);
 119
 120   }
 121
 122   public boolean testEdge(ConflictEdge newEdge) {
 123
 124     if (!conflictNodeSet.contains(newEdge.getVertexU())
 125         && !conflictNodeSet.contains(newEdge.getVertexV())) {
 126       return false;
 127     }
 128
 129     ConflictNode nodeToAdd = conflictNodeSet.contains(newEdge.getVertexU()) ? newEdge.getVertexV()
 130         : newEdge.getVertexU();
 131
 132     HashSet<ConflictNode> nodeSet = new HashSet<ConflictNode>(conflictNodeSet);
 133
 134     for (Iterator edgeIter = nodeToAdd.getEdgeSet().iterator(); edgeIter.hasNext();) {
 135       ConflictEdge edge = (ConflictEdge) edgeIter.next();
 136       if (nodeSet.contains(edge.getVertexU())) {
 137         nodeSet.remove(edge.getVertexU());
 138       } else if (nodeSet.contains(edge.getVertexV())) {
 139         nodeSet.remove(edge.getVertexV());
 140       }
 141     }
 142
 143     return nodeSet.isEmpty();
 144
 145   }
 146
 147   public String toString() {
 148     String rtr = "";
 149
 150     for (Iterator<ConflictNode> iterator = conflictNodeSet.iterator(); iterator.hasNext();) {
 151       ConflictNode node = (ConflictNode) iterator.next();
 152       rtr += " " + node + "::" + getNodeType(node);
 153     }
 154
 155     return rtr;
 156   }
 157
 158 }