예제 #1
0
 /** Propagate the results of creating a new SCC with this node as lead. */
 public void propagateSCC() {
   Set<GraphNode> visited = new HashSet<>();
   visited.add(this);
   // Scan predecessors not including ourselves
   doVisitPredecessors(
       new Visitor<Set<GraphNode>, Object>() {
         @Override
         public List<GraphNode> visit(
             GraphNode node, GraphNode processing, Set<GraphNode> sc, Object ignored) {
           // Add closure
           node.succClosed.addAll(sc);
           // Scan for redundant links
           List<GraphNode> kill = null;
           for (Iterator<GraphNode> i = node.succ.iterator(); i.hasNext(); ) {
             GraphNode s = i.next();
             if (sc.contains(s)) {
               i.remove();
               //                            s.pred.remove(node);
               if (s == processing) {
                 // Can't remove immediately w/o beaking the visitor loop
                 if (kill == null) kill = new ArrayList<>();
                 kill.add(node);
               } else {
                 s.pred.remove(node);
               }
             }
           }
           return kill;
         }
       },
       succClosed,
       null,
       visited);
 }
예제 #2
0
 /** Propagate the results of adding a link from this node to the target node. */
 public void propagateAdd(GraphNode target) {
   Set<GraphNode> sc = new HashSet<>(target.succClosed);
   sc.add(target);
   visitPredecessors(
       new Visitor<Set<GraphNode>, GraphNode>() {
         @Override
         public List<GraphNode> visit(
             GraphNode node, GraphNode processing, Set<GraphNode> sc, GraphNode target) {
           // Add closure
           node.succClosed.addAll(sc);
           // Scan for redundant links
           List<GraphNode> kill = null;
           for (Iterator<GraphNode> i = node.succ.iterator(); i.hasNext(); ) {
             GraphNode s = i.next();
             if (sc.contains(s)) {
               i.remove();
               if (s == processing) {
                 // Can't remove immediately w/o beaking the visitor loop
                 if (kill == null) kill = new ArrayList<>();
                 kill.add(node);
               } else {
                 s.pred.remove(node);
               }
             }
           }
           return kill;
         }
       },
       sc,
       target);
 }
예제 #3
0
 /** Visit each predecessor of this node applying the given visitor. Breadth first. */
 private <Alpha, Beta> void doVisitPredecessors(
     Visitor<Alpha, Beta> visitor, Alpha arg1, Beta arg2, Set<GraphNode> seen) {
   if (seen.add(this)) {
     Collection<GraphNode> allKill = null;
     for (Iterator<GraphNode> i = pred.iterator(); i.hasNext(); ) {
       GraphNode pred = i.next();
       List<GraphNode> kill = visitor.visit(pred, this, arg1, arg2);
       if (kill != null) {
         if (allKill == null) allKill = new ArrayList<GraphNode>();
         allKill.addAll(kill);
       }
     }
     if (allKill != null) pred.removeAll(allKill);
     for (Iterator<GraphNode> i = pred.iterator(); i.hasNext(); ) {
       GraphNode pred = i.next();
       pred.doVisitPredecessors(visitor, arg1, arg2, seen);
     }
   }
 }
예제 #4
0
 void addInto(Set<GraphNode> nodes, GraphNode m) {
   nodes.add(m);
 }
예제 #5
0
 /** Assert an inferred indirect link from this node to the given traget */
 public void assertIndirectLinkTo(GraphNode target) {
   //            if (this == target) return;
   succClosed.add(target);
   clearTripleCache();
 }
예제 #6
0
 /**
  * Assert a direct link between this node and this given target. Does not update the closed
  * successor cache
  */
 public void assertLinkTo(GraphNode target) {
   if (this == target) return;
   succ.add(target);
   target.pred.add(this);
   clearTripleCache();
 }