@Override public void apply(final Individual x) { if (!x.canApply(Node.MAX)) return; final List<ATermAppl> maxCardinality = x.getTypes(Node.MAX); final Iterator<ATermAppl> j = maxCardinality.iterator(); while (j.hasNext()) { final ATermAppl maxCard = j.next(); apply(x, maxCard); } }
@Override public void apply(final Individual x) { if (!x.canApply(Node.MAX)) return; final List<ATermAppl> maxCardinality = x.getTypes(Node.MAX); final Iterator<ATermAppl> j = maxCardinality.iterator(); while (j.hasNext()) { final ATermAppl maxCard = j.next(); apply(x, maxCard); } }
@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 apply(final Individual node) { if (!node.canApply(Node.ATOM)) return; final List<ATermAppl> types = node.getTypes(Node.ATOM); int size = types.size(); for (int j = node._applyNext[Node.ATOM]; j < size; j++) { final ATermAppl c = types.get(j); if (!OpenlletOptions.MAINTAIN_COMPLETION_QUEUE && node.getDepends(c) == null) continue; applyUnfoldingRule(node, c); if (_strategy.getABox().isClosed()) return; // it is possible that unfolding added new atomic // concepts that we need to further unfold size = types.size(); } node._applyNext[Node.ATOM] = size; }
/** * 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; }
/** * 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 node) { if (!node.canApply(Node.ATOM)) return; final List<ATermAppl> types = node.getTypes(Node.ATOM); int size = types.size(); for (int j = node._applyNext[Node.ATOM]; j < size; j++) { final ATermAppl c = types.get(j); if (!OpenlletOptions.MAINTAIN_COMPLETION_QUEUE && node.getDepends(c) == null) continue; applyUnfoldingRule(node, c); if (_strategy.getABox().isClosed()) return; // it is possible that unfolding added new atomic // concepts that we need to further unfold size = types.size(); } node._applyNext[Node.ATOM] = size; }
@Override public void apply(final Individual node) { if (!node.canApply(Node.OR)) return; final List<ATermAppl> types = node.getTypes(Node.OR); final int size = types.size(); final ATermAppl[] disjunctions = new ATermAppl[size - node._applyNext[Node.OR]]; types.subList(node._applyNext[Node.OR], size).toArray(disjunctions); if (OpenlletOptions.USE_DISJUNCTION_SORTING != OpenlletOptions.NO_SORTING) sortDisjunctions(node, disjunctions); for (final ATermAppl disjunction : disjunctions) { applyDisjunctionRule(node, disjunction); if (_strategy.getABox().isClosed() || node.isMerged()) return; } node._applyNext[Node.OR] = size; }
@Override public void apply(final Individual node) { if (!node.canApply(Node.OR)) return; final List<ATermAppl> types = node.getTypes(Node.OR); final int size = types.size(); final ATermAppl[] disjunctions = new ATermAppl[size - node._applyNext[Node.OR]]; types.subList(node._applyNext[Node.OR], size).toArray(disjunctions); if (OpenlletOptions.USE_DISJUNCTION_SORTING != OpenlletOptions.NO_SORTING) sortDisjunctions(node, disjunctions); for (final ATermAppl disjunction : disjunctions) { applyDisjunctionRule(node, disjunction); if (_strategy.getABox().isClosed() || node.isMerged()) return; } node._applyNext[Node.OR] = size; }