Stack workset=new Stack();
HashSet closureset=new HashSet();
boolean needcyclecheck=false;
- HashSet cantremovetrans=new HashSet();
+ HashSet dependent=new HashSet();
+
+ /* Compute dependent set */
+ workset.push(gn);
+ while(!workset.empty()) {
+ GraphNode gn2=(GraphNode)workset.pop();
+ for(Iterator edgeit=gn2.edges();edgeit.hasNext();) {
+ GraphNode gn3=((GraphNode.Edge)edgeit.next()).getTarget();
+ if (removed.contains(gn3))
+ continue;
+ if (!termination.conjunctions.contains(gn3)&&!dependent.contains(gn3)) {
+ dependent.add(gn3);
+ workset.push(gn3);
+ }
+ }
+ }
+
+ /* Compute the closure set */
workset.push(gn);
while(!workset.empty()) {
GraphNode gn2=(GraphNode)workset.pop();
if (!closureset.contains(gn2)) {
closureset.add(gn2);
- boolean goodoption=false;
for(Iterator edgeit=gn2.edges();edgeit.hasNext();) {
GraphNode gn3=((GraphNode.Edge)edgeit.next()).getTarget();
if (removed.contains(gn3))
continue;
- if (((cantremove.contains(gn2)||!couldremove.contains(gn2))
- &&termination.conjunctions.contains(gn2))||
- cantremovetrans.contains(gn2))
- cantremovetrans.add(gn3);
-
- if (termination.abstractrepair.contains(gn3)||
- termination.conjunctions.contains(gn3)||
- termination.updatenodes.contains(gn3)) {
- /** Check for cycles if the graphnode can't
- * be removed (we know we aren't introducing
- * new things to repair). */
- if ((!termination.abstractrepair.contains(gn3)&&
- cantremove.contains(gn3))||
- cantremovetrans.contains(gn3)) {
- needcyclecheck=true;
- } else return false;
- }
- if ((!couldremove.contains(gn3))||cantremove.contains(gn3))
- goodoption=true;
workset.push(gn3);
}
- if (!goodoption) {
- if (termination.scopenodes.contains(gn2))
- return false;
- }
}
}
- if (needcyclecheck) {
- Set cycles=GraphNode.findcycles(closureset);
- for(Iterator it=cycles.iterator();it.hasNext();) {
- GraphNode gn2=(GraphNode)it.next();
- if (termination.abstractrepair.contains(gn2)||
- termination.conjunctions.contains(gn2)||
- termination.updatenodes.contains(gn2))
- return false;
+
+ /* Check for harmful cycles through gn */
+ Set cycles=GraphNode.findcycles(closureset);
+ if (cycles.contains(gn))
+ return false;
+
+ /* Check for harmful cycles being introduced in dependent nodes */
+ cycles=GraphNode.findcycles(dependent);
+ for(Iterator it=cycles.iterator();it.hasNext();) {
+ GraphNode gn2=(GraphNode)it.next();
+ if (termination.abstractrepair.contains(gn2)||
+ termination.conjunctions.contains(gn2)||
+ termination.updatenodes.contains(gn2))
+ return false;
+ }
+
+ /* Make sure all abstractrepairs/consequence nodes in the dependent nodes
+ are well formed. */
+ outerloop:
+ for(Iterator it=dependent.iterator();it.hasNext();) {
+ GraphNode gn2=(GraphNode)it.next();
+ if (termination.abstractrepair.contains(gn2)||
+ termination.scopenodes.contains(gn2)) {
+ boolean ismodify=false;
+ int numadd=0;
+ int numremove=0;
+
+ if (termination.abstractrepair.contains(gn2)&&
+ ((TermNode)gn2.getOwner()).getAbstract().getType()==AbstractRepair.MODIFYRELATION)
+ ismodify=true;
+
+ innerloop:
+ for(Iterator edgeit=gn2.edges();edgeit.hasNext();) {
+ GraphNode gn3=((GraphNode.Edge)edgeit.next()).getTarget();
+ if (removed.contains(gn3))
+ continue innerloop;
+ if (cantremove.contains(gn3)||
+ !couldremove.contains(gn3)) {
+ if (ismodify) {
+ TermNode tn3=(TermNode)gn3.getOwner();
+ MultUpdateNode mun=tn3.getUpdate();
+ if (mun.getType()==MultUpdateNode.ADD)
+ numadd++;
+ if (mun.getType()==MultUpdateNode.REMOVE)
+ numremove++;
+ if (mun.getType()==MultUpdateNode.MODIFY)
+ continue outerloop;
+ if ((numadd>0)&&(numremove>0||!((TermNode)gn2.getOwner()).getAbstract().needsRemoves(termination.state)))
+ continue outerloop;
+ } else
+ if (termination.consequence.contains(gn3)||
+ termination.updatenodes.contains(gn3))
+ continue outerloop;
+ }
+ }
+ return false;
}
}
return true;
for(Iterator it=termination.consequencenodes.iterator();it.hasNext();) {
GraphNode gn=(GraphNode) it.next();
if (safetransclosure(gn, mustremove,cantremove, couldremove)) {
- couldremove.remove(gn);
+ couldremove.remove(gn);
}
}
for(Iterator it=termination.updatenodes.iterator();it.hasNext();) {
GraphNode gn=(GraphNode) it.next();
- if (safetransclosure(gn, mustremove,cantremove, cantremove)) {
- couldremove.remove(gn);
+ if (safetransclosure(gn, mustremove,cantremove, couldremove)) {
+ couldremove.remove(gn);
}
}
GraphNode gn=(GraphNode) it.next();
if (mustremove.contains(gn)||cantremove.contains(gn))
continue;
- if (!safetransclosure(gn, mustremove,cantremove, cantremove))
+ if (!safetransclosure(gn, mustremove,cantremove, couldremove))
continue;
boolean allgood=true;
}
- /* Search through conjunction which must be satisfied, and attempt
- to generate appropriate repair actions.
- */
+ /* Search through conjunction nodes which must be
+ satisfied, and see if there are any data structure
+ updates that must exist. */
+
HashSet newset=new HashSet();
for(Iterator cit=cantremove.iterator();cit.hasNext();) {
GraphNode gn=(GraphNode)cit.next();
/* Searches individual conjunctions + abstract action +updates for cycles */
for(Iterator it=termination.conjunctions.iterator();it.hasNext();) {
GraphNode gn=(GraphNode)it.next();
- boolean foundnocycle=false;
for (Iterator edgeit=gn.edges();edgeit.hasNext();) {
+ boolean foundnocycle=false;
+
GraphNode.Edge e=(GraphNode.Edge)edgeit.next();
GraphNode gn2=e.getTarget();
TermNode tn2=(TermNode)gn2.getOwner();
mustremove.add(gn3);
}
}
- }
- if(!foundnocycle) {
- if (!mustremove.contains(gn)) {
- change=true;
- mustremove.add(gn);
- }
- }
+
+ if(!foundnocycle) {
+ if (!mustremove.contains(gn)) {
+ change=true;
+ mustremove.add(gn);
+ }
+ }
+ }
}
/* Searches scope nodes + compensation nodes */
for(Iterator it=termination.scopenodes.iterator();it.hasNext();) {
GraphNode gn=(GraphNode)it.next();
- int count=0;
if (nodes.contains(gn)) {
for (Iterator edgeit=gn.edges();edgeit.hasNext();) {
GraphNode.Edge e=(GraphNode.Edge)edgeit.next();
GraphNode gn2=e.getTarget();
TermNode tn2=(TermNode)gn2.getOwner();
- if ((tn2.getType()==TermNode.CONSEQUENCE)&&
- !mustremove.contains(gn2))
- count++;
-
-
if (tn2.getType()!=TermNode.UPDATE)
continue;
/* We have a compensation node */
change=true;
mustremove.add(gn2);
}
- } else {
- if (!mustremove.contains(gn2))
- count++;
}
if (!containsgn)
cantremove.remove(gn);
if (!containsgn2)
cantremove.remove(gn2);
}
-
- if (count==1) {
- for (Iterator edgeit=gn.edges();edgeit.hasNext();) {
- GraphNode.Edge e=(GraphNode.Edge)edgeit.next();
- GraphNode gn2=e.getTarget();
- TermNode tn2=(TermNode)gn2.getOwner();
- if ((tn2.getType()==TermNode.UPDATE||tn2.getType()==TermNode.CONSEQUENCE)&&
- !mustremove.contains(gn2)) {
- if (!cantremove.contains(gn2)) {
- cantremove.add(gn2);
- change=true;
- }
- }
- }
- }
}
}
couldremove.removeAll(mustremove);
foundrepair=true;
}
}
- if (!foundrepair)
+ if (!foundrepair) {
return ERR_NOREPAIR;
+ }
}