public void removeUndefeated( DefeasibleLogicalDependency dep, LinkedListEntry<DefeasibleLogicalDependency> node) { boolean pos = dep.getValue() == null || MODE.POSITIVE.getId().equals(dep.getValue().toString()); switch (dep.getStatus()) { case DEFINITELY: if (pos) { definitelyPosCount--; if (definitelyPosCount == 0) { statusMask = statusMask ^ DEFINITELY_POS_BIT; } } else { definitelyNegCount--; if (definitelyNegCount == 0) { statusMask = statusMask ^ DEFINITELY_NEG_BIT; } } break; case DEFEASIBLY: if (pos) { defeasiblyPosCount--; if (defeasiblyPosCount == 0) { statusMask = statusMask ^ DEFEASIBLY_POS_BIT; } } else { defeasiblyNegCount--; if (defeasiblyNegCount == 0) { statusMask = statusMask ^ DEFEASIBLY_NEG_BIT; } } break; case DEFEATEDLY: if (pos) { defeatedlyPosCount--; if (defeatedlyPosCount == 0) { statusMask = statusMask ^ DEFEATEDLY_POS_BIT; } } else { defeatedlyNegCount--; if (defeatedlyNegCount == 0) { statusMask = statusMask ^ DEFEATEDLY_NEG_BIT; } } break; case UNDECIDABLY: throw new IllegalStateException("Individual logical dependencies cannot be undecidably"); } if (this.rootUndefeated == node) { removeFirst(); } else if (this.tailUndefeated == node) { removeLast(); } else { node.getPrevious().setNext(node.getNext()); ((LinkedListNode) node.getNext()).setPrevious(node.getPrevious()); node.nullPrevNext(); } }
public void add(LinkedListNode node) { DefeasibleLogicalDependency newDep = (DefeasibleLogicalDependency) ((LinkedListEntry) node).getObject(); newDep.setStatus(resolveStatus(newDep)); Rule rule = newDep.getJustifier().getRule(); // first iterate to see if this new dep is defeated. If it's defeated, it can no longer impacts // any deps // if we checked what it defeats, and later this was defeated, we would have undo action. So we // do the cheaper work first. boolean wasDefeated = false; for (LinkedListEntry<DefeasibleLogicalDependency> existingNode = rootUndefeated; existingNode != null; existingNode = existingNode.getNext()) { DefeasibleLogicalDependency existingDep = existingNode.getObject(); wasDefeated = checkAndApplyIsDefeated(newDep, rule, existingDep); if (wasDefeated) { break; } } if (!wasDefeated) { LinkedListEntry<DefeasibleLogicalDependency> stagedDeps = null; // for (DefeasibleLogicalDependency existingDep = rootUndefeated; existingDep != null; ) { for (LinkedListEntry<DefeasibleLogicalDependency> existingNode = rootUndefeated; existingNode != null; ) { LinkedListEntry<DefeasibleLogicalDependency> next = existingNode.getNext(); DefeasibleLogicalDependency existingDep = existingNode.getObject(); if (checkAndApplyIsDefeated(existingDep, existingDep.getJustifier().getRule(), newDep)) { // fist remove it from the undefeated list removeUndefeated(existingDep, existingNode); if (existingDep.getRootDefeated() != null) { // build up the list of staged deps, that will need to be reprocessed if (stagedDeps == null) { stagedDeps = existingDep.getRootDefeated(); } else { stagedDeps.setPrevious(existingDep.getTailDefeated()); stagedDeps = existingDep.getRootDefeated(); } } existingDep.clearDefeated(); } existingNode = next; } addUndefeated(newDep, (LinkedListEntry<DefeasibleLogicalDependency>) node); // now process the staged reprocessDefeated(stagedDeps); } updateStatus(); }
public void addUndefeated( DefeasibleLogicalDependency dep, LinkedListEntry<DefeasibleLogicalDependency> node) { boolean pos = dep.getValue() == null || MODE.POSITIVE.getId().equals(dep.getValue().toString()); switch (dep.getStatus()) { case DEFINITELY: if (pos) { definitelyPosCount++; statusMask = statusMask | DEFINITELY_POS_BIT; } else { definitelyNegCount++; statusMask = statusMask | DEFINITELY_NEG_BIT; } break; case DEFEASIBLY: if (pos) { defeasiblyPosCount++; statusMask = statusMask | DEFEASIBLY_POS_BIT; } else { defeasiblyNegCount++; statusMask = statusMask | DEFEASIBLY_NEG_BIT; } break; case DEFEATEDLY: if (pos) { defeatedlyPosCount++; statusMask = statusMask | DEFEATEDLY_POS_BIT; } else { defeatedlyNegCount++; statusMask = statusMask | DEFEATEDLY_NEG_BIT; } break; case UNDECIDABLY: throw new IllegalStateException("Individual logical dependencies cannot be undecidably"); } if (rootUndefeated == null) { rootUndefeated = node; tailUndefeated = node; } else { if (dep.getStatus() == DefeasibilityStatus.DEFINITELY) { // Strict dependencies at to the front rootUndefeated.setPrevious(node); node.setNext(rootUndefeated); rootUndefeated = node; } else { // add to end tailUndefeated.setNext(node); node.setPrevious(tailUndefeated); tailUndefeated = node; } } }
public void cancel(PropagationContext propagationContext) { // get all but last, as that we'll do via the BeliefSystem, for cleanup // note we don't update negative, conflict counters. It's needed for the last cleanup operation FastIterator it = iterator(); for (LinkedListEntry<DefeasibleLogicalDependency> node = getFirst(); node != tailUndefeated; ) { LinkedListEntry<DefeasibleLogicalDependency> temp = (LinkedListEntry<DefeasibleLogicalDependency>) it.next(node); // get next, as we are about to remove it final DefeasibleLogicalDependency dep = node.getObject(); dep.getJustifier().getLogicalDependencies().remove(dep); remove(dep); node = temp; } LinkedListEntry last = (LinkedListEntry) getFirst(); final LogicalDependency node = (LogicalDependency) last.getObject(); node.getJustifier().getLogicalDependencies().remove(node); // beliefSystem.delete( node, this, context ); positiveFactHandle = null; negativeFactHandle = null; }
public void remove(LinkedListNode node) { DefeasibleLogicalDependency dep = ((LinkedListEntry<DefeasibleLogicalDependency>) node).getObject(); if (dep.getDefeatedBy() != null) { // Defeated deps do not have defeated defeated lists of their own, so just remove. DefeasibleLogicalDependency defeater = dep.getDefeatedBy(); defeater.removeDefeated(dep); } else { // ins undefeated, process it's defeated list if they exist removeUndefeated(dep, (LinkedListEntry<DefeasibleLogicalDependency>) node); if (dep.getRootDefeated() != null) { reprocessDefeated(dep.getRootDefeated()); } } updateStatus(); }
public Entry next(Entry object) { DefeasibleLogicalDependency dep = (DefeasibleLogicalDependency) object; if (dep.getRootDefeated() != null) { // try going down the list of defeated first return dep.getRootDefeated(); } if (dep.getNext() != null) { return dep.getNext(); } if (dep.getDefeatedBy() != null) { // go back up to the parent undefeated, and try the next undefeated return dep.getDefeatedBy().getNext(); } return null; // nothing more to iterate too. }
private boolean checkAndApplyIsDefeated( DefeasibleLogicalDependency potentialInferior, Rule rule, DefeasibleLogicalDependency potentialSuperior) { if (potentialSuperior.getDefeats() == null) { return false; } if (potentialSuperior.getStatus() == DefeasibilityStatus.DEFINITELY && potentialInferior.getStatus() != DefeasibilityStatus.DEFINITELY) { potentialSuperior.addDefeated(potentialInferior); return true; } // adds the references that defeat the current node if (Arrays.binarySearch(potentialSuperior.getDefeats(), rule.getName()) >= 0 || Arrays.binarySearch( potentialSuperior.getDefeats(), rule.getPackage() + "." + rule.getName()) >= 0) { potentialSuperior.addDefeated(potentialInferior); return true; } return false; }