@Override public void flushQueue() { if (!_backtracked && !_closed) _queue.clear(); else if (_closed) if (!_abox.isClosed()) _closed = false; _queue.addAll(_newQueueList); _newQueue.clear(); _newQueueList.clear(); _end = _queue.size(); _backtracked = false; }
@Override public void flushQueue() { if (!_backtracked && !_closed) _queue.clear(); else if (_closed) if (!_abox.isClosed()) _closed = false; _queue.addAll(_newQueueList); _newQueue.clear(); _newQueueList.clear(); _end = _queue.size(); _backtracked = false; }
@Override public void flushQueue() { for (int i = 0; i < NodeSelector.numSelectors(); i++) { if (!_backtracked && !_closed) _queue[i].clear(); else if (_closed) if (!_abox.isClosed()) _closed = false; _queue[i].addAll(_newQueueList[i]); _newQueue[i].clear(); _newQueueList[i].clear(); _end[i] = _queue[i].size(); } _backtracked = false; }
@Override public void apply(final Individual x) { if (x.isBlockable()) return; final List<ATermAppl> types = x.getTypes(Node.MAX); final int size = types.size(); for (int j = 0; j < size; j++) { final ATermAppl mc = types.get(j); applyGuessingRule(x, mc); if (_strategy.getABox().isClosed()) return; } }
@Override public void apply(final Individual x) { if (x.isBlockable()) return; final List<ATermAppl> types = x.getTypes(Node.MAX); final int size = types.size(); for (int j = 0; j < size; j++) { final ATermAppl mc = types.get(j); applyGuessingRule(x, mc); if (_strategy.getABox().isClosed()) return; } }
@Override public void apply(final Individual ind) { if (!ind.canApply(Node.MIN)) return; // We get all the minCard restrictions in the _node and store them in the list ''types'' final List<ATermAppl> types = ind.getTypes(Node.MIN); final int size = types.size(); for (int j = ind._applyNext[Node.MIN]; j < size; j++) { final ATermAppl mc = types.get(j); // mc stores the _current type (the _current minCard restriction) apply(ind, mc); if (_strategy.getABox().isClosed()) return; } ind._applyNext[Node.MIN] = size; }
@Override public void apply(final Individual ind) { if (!ind.canApply(Node.MIN)) return; // We get all the minCard restrictions in the _node and store them in the list ''types'' final List<ATermAppl> types = ind.getTypes(Node.MIN); final int size = types.size(); for (int j = ind._applyNext[Node.MIN]; j < size; j++) { final ATermAppl mc = types.get(j); // mc stores the _current type (the _current minCard restriction) apply(ind, mc); if (_strategy.getABox().isClosed()) return; } ind._applyNext[Node.MIN] = size; }
@Override public void mergeTo(final Node y, final Node z, final DependencySet ds) { _merging = true; super.mergeTo(y, z, ds); if (!_abox.isClosed() && _interpreter != null && (y.isRootNominal() || z.isRootNominal())) { // if( y.isRootNominal() ) // runRules |= interpreter.removeMentions( y.getTerm() ); // if( z.isIndividual() ) // runRules |= interpreter.rete.processIndividual( (Individual) z ); } _merging = false; }
@Override public void mergeTo(final Node y, final Node z, final DependencySet ds) { _merging = true; super.mergeTo(y, z, ds); if (!_abox.isClosed() && _interpreter != null && (y.isRootNominal() || z.isRootNominal())) { // if( y.isRootNominal() ) // runRules |= interpreter.removeMentions( y.getTerm() ); // if( z.isIndividual() ) // runRules |= interpreter.rete.processIndividual( (Individual) z ); } _merging = false; }
/** * Apply max rule to the individual. */ @Override public void apply(final Individual ind) { if (!ind.canApply(Node.MAX)) return; final List<ATermAppl> maxCardinality = ind.getTypes(Node.MAX); for (int i = 0; i < maxCardinality.size(); i++) { final ATermAppl mc = maxCardinality.get(i); applyMaxRule(ind, mc); if (_strategy.getABox().isClosed()) return; if (ind.isMerged()) return; } ind._applyNext[Node.MAX] = maxCardinality.size(); }
@Override public void apply(final Individual x) { if (!x.canApply(Node.SOME)) return; final List<ATermAppl> types = x.getTypes(Node.SOME); final int size = types.size(); for (int j = x._applyNext[Node.SOME]; j < size; j++) { final ATermAppl sv = types.get(j); applySomeValuesRule(x, sv); if (_strategy.getABox().isClosed() || x.isPruned()) return; } x._applyNext[Node.SOME] = size; }
@Override public void apply(final Individual x) { if (!x.canApply(Node.SOME)) return; final List<ATermAppl> types = x.getTypes(Node.SOME); final int size = types.size(); for (int j = x._applyNext[Node.SOME]; j < size; j++) { final ATermAppl sv = types.get(j); applySomeValuesRule(x, sv); if (_strategy.getABox().isClosed() || x.isPruned()) return; } x._applyNext[Node.SOME] = size; }
@Override public Edge addEdge(final Individual subj, final Role pred, final Node obj, final DependencySet ds) { final Edge edge = super.addEdge(subj, pred, obj, ds); if (edge != null && !_abox.isClosed() && subj.isRootNominal() && obj.isRootNominal()) if (_interpreter != null) _interpreter._alphaNet.activateEdge(edge); return edge; }
@Override public Edge addEdge(final Individual subj, final Role pred, final Node obj, final DependencySet ds) { final Edge edge = super.addEdge(subj, pred, obj, ds); if (edge != null && !_abox.isClosed() && subj.isRootNominal() && obj.isRootNominal()) if (_interpreter != null) _interpreter._alphaNet.activateEdge(edge); return edge; }
public boolean tryNext() { // nothing more to try, update the clash dependency if (getTryNext() == getTryCount()) if (!_abox.isClosed()) _abox.setClash(Clash.unexplained(getNode(), _termDepends)); else _abox.getClash().setDepends(getCombinedClash()); // if there is no clash try next possibility if (!_abox.isClosed()) tryBranch(); // there is a clash so there is no point in trying this // _branch again. remove this _branch from clash dependency if (_abox.isClosed()) if (!OpenlletOptions.USE_INCREMENTAL_DELETION) _abox.getClash().getDepends().remove(getBranchIndexInABox()); return !_abox.isClosed(); }
@Override public void addType(final Node node, final ATermAppl c, final DependencySet ds) { super.addType(node, c, ds); if (!_merging && !_abox.isClosed() && node.isRootNominal() && _interpreter != null && node.isIndividual()) { final Individual ind = (Individual) node; _interpreter._alphaNet.activateType(ind, c, ds); } }
@Override public void addType(final Node node, final ATermAppl c, final DependencySet ds) { super.addType(node, c, ds); if (!_merging && !_abox.isClosed() && node.isRootNominal() && _interpreter != null && node.isIndividual()) { final Individual ind = (Individual) node; _interpreter._alphaNet.activateType(ind, c, ds); } }
@Override public boolean setDifferent(final Node y, final Node z, final DependencySet ds) { if (super.setDifferent(y, z, ds)) { if (_interpreter != null && !_merging && !_abox.isClosed() && y.isRootNominal() && y.isIndividual() && z.isRootNominal() && z.isIndividual()) _interpreter._alphaNet.activateDifferent((Individual) y, (Individual) z, ds); return true; } return false; }
@Override public boolean setDifferent(final Node y, final Node z, final DependencySet ds) { if (super.setDifferent(y, z, ds)) { if (_interpreter != null && !_merging && !_abox.isClosed() && y.isRootNominal() && y.isIndividual() && z.isRootNominal() && z.isIndividual()) _interpreter._alphaNet.activateDifferent((Individual) y, (Individual) z, ds); return true; } return false; }
@Override public final void apply(final Individual node) { for (final ATermAppl c : new ArrayList<>(node.getTypes(Node.ATOM))) // 'applyAllValues' can change the underlying types of individual; so we make a copy to iterate { if (!OpenlletOptions.MAINTAIN_COMPLETION_QUEUE && null == node.getDepends(c)) continue; if (ATermUtils.isSelf(c)) { final ATermAppl predicate = (ATermAppl) c.getArgument(0); final Role role = _strategy.getABox().getRole(predicate); _logger.fine(() -> "SELF: " + node + "\trole:" + role + "\tdepends:" + node.getDepends(c) + "\tRSuccessor:" + node.hasRSuccessor(role, node)); _strategy.addEdge(node, role, node, node.getDepends(c)); if (_strategy.getABox().isClosed()) return; } } } }