public int CompareTo(ThreatenedLinkFlaw other) { if (other == null) { return(1); } if (threatener.ID == other.threatener.ID) { if (causallink.Predicate.Equals(other.causallink.Predicate)) { if (causallink.Head.ID != other.causallink.Head.ID) { if (causallink.Head.ID < other.causallink.Head.ID) { return(-1); } else { return(1); } } else if (causallink.Tail.ID != other.causallink.Tail.ID) { if (causallink.Tail.ID < other.causallink.Tail.ID) { return(-1); } else { return(1); } } // causal link is the same, and the threat is the same throw new System.Exception(); } else { return(PredicateComparer.CompareTo(causallink.Predicate, other.causallink.Predicate)); } } else if (threatener.ID < other.threatener.ID) { return(-1); } else { return(1); } }
public int CompareTo(OpenCondition other) { if (other == null) { return(1); } // check static if (isStatic && !other.isStatic) { return(-1); } else if (other.isStatic && !isStatic) { return(1); } if (step.Depth > other.step.Depth) { return(1); } else if (step.Depth < other.step.Depth) { return(-1); } // MW-Loc-Conf = {threats} LIFO / {unsafe} MW_add / {local} MW_add // if one is unsafe and the other is not. if (risks > 0 && other.risks == 0) { return(-1); } else if (other.risks > 0 && risks == 0) { return(1); } if (other.risks > 0 && risks == other.risks) { // if they are both unsafe, choose one with most work if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else { return(1); } } // Local step's open conditions first. Lower planstep ID == added to plan earlier if (step.ID < other.step.ID) { return(-1); } else if (step.ID > other.step.ID) { return(1); } // If they are of the same step, only then do we select between mos work... if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else if (addReuseHeuristic < other.addReuseHeuristic) { return(1); } // tiebreaker if they are the same work if (precondition.Equals(other.precondition)) { throw new System.Exception(); } else { return(PredicateComparer.CompareTo(precondition, other.precondition)); } }
public int CompareTo(OpenCondition other) { if (other == null) { return(1); } // check static if (isStatic && !other.isStatic) { return(-1); } else if (other.isStatic && !isStatic) { return(1); } // {dummyGoal} LIFO // take care of open conditions arising from substeps that are found in initial step. //if (isDummyGoal && !other.isDummyGoal) //{ // return -1; //} //else if (other.isDummyGoal && !isDummyGoal) //{ // return 1; //} //else if (other.isDummyGoal && isDummyGoal) //{ // if (addReuseHeuristic > other.addReuseHeuristic) // { // return -1; // } // else // { // return 1; // } //} ////take care of open conditions arising from substeps that are found in initial step. //if (hasDummyInit && !other.hasDummyInit) //{ // return -1; //} //else if (other.hasDummyInit && !hasDummyInit) //{ // return 1; //} //else if (other.hasDummyInit && hasDummyInit) //{ // if (addReuseHeuristic > other.addReuseHeuristic) // { // return -1; // } // else // { // return 1; // } //} if (step.Depth > other.step.Depth) { return(1); } else if (step.Depth < other.step.Depth) { return(-1); } if (precondition.Name.Equals("obss") || precondition.Name.Equals("obs-starts")) { if (other.precondition.Name.Equals("obss") || other.precondition.Name.Equals("obs-starts")) { if (risks > 0 && other.risks == 0) { return(-1); } else if (other.risks > 0 && risks == 0) { return(1); } if (other.risks > 0 && risks == other.risks) { // if they are both unsafe, choose one with most work if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else { return(1); } } // Local step's open conditions first. Lower planstep ID == added to plan earlier if (step.ID < other.step.ID) { return(-1); } else if (step.ID > other.step.ID) { return(1); } // If they are of the same step, only then do we select between mos work... if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else if (addReuseHeuristic < other.addReuseHeuristic) { return(1); } } else { return(-1); } } else if (other.precondition.Name.Equals("obs-starts") || other.precondition.Name.Equals("obss")) { return(1); } // MW-Loc-Conf = {threats} LIFO / {unsafe} MW_add / {local} MW_add // if one is unsafe and the other is not. if (risks > 0 && other.risks == 0) { return(-1); } else if (other.risks > 0 && risks == 0) { return(1); } if (other.risks > 0 && risks == other.risks) { // if they are both unsafe, choose one with most work if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else { return(1); } } // Local step's open conditions first. Lower planstep ID == added to plan earlier if (step.ID < other.step.ID) { return(-1); } else if (step.ID > other.step.ID) { return(1); } // If they are of the same step, only then do we select between mos work... if (addReuseHeuristic > other.addReuseHeuristic) { return(-1); } else if (addReuseHeuristic < other.addReuseHeuristic) { return(1); } // tiebreaker if they are the same work if (precondition.Equals(other.precondition)) { throw new System.Exception(); } else { return(PredicateComparer.CompareTo(precondition, other.precondition)); } }
public int CompareTo(OpenCondition other) { if (other == null) { return(1); } // check static if (isStatic && !other.isStatic) { return(-1); } else if (other.isStatic && !isStatic) { return(1); } // check init if (isInit && !other.isInit) { return(-1); } else if (other.isInit && !isInit) { return(1); } // check risks if (risks > 0 || other.risks > 0) { if (risks > other.risks) { return(-1); } else if (risks < other.risks) { return(1); } } // check cndts if (cndts > other.cndts) { return(-1); } else if (cndts < other.cndts) { return(1); } // resort to tiebreak criteria if (step.ID == other.step.ID) { if (precondition.Equals(other.precondition)) { throw new System.Exception(); } else { return(PredicateComparer.CompareTo(precondition, other.precondition)); } } else if (step.ID < other.step.ID) { return(-1); } else { return(1); } }