allValuesRule.apply( n );
}
//process new edges
for(Iterator<Edge> it = getNewEdgeIterator(); it.hasNext();){
Edge edge = it.next();
Individual subj = edge.getFrom();
Node obj = edge.getTo();
if(subj.isMerged())
subj.getSame();
if(subj.isPruned())
continue;
if(obj.isMerged())
obj.getSame();
if(obj.isPruned())
continue;
Role pred = edge.getRole();
DependencySet ds = edge.getDepends();
applyDomainRange(subj, pred, obj, ds);
if (subj.isPruned() || obj.isPruned()) {
return;
}
applyFunctionality(subj, pred, obj);
if (subj.isPruned() || obj.isPruned()) {
return;
}
if (pred.isObjectRole()) {
Individual o = (Individual) obj;
checkReflexivitySymmetry(subj, pred, o, ds);
checkReflexivitySymmetry(o, pred.getInverse(), subj, ds);
}
//if the KB has cardinality restrictions, then we need to apply the guessing rule
if(abox.getKB().getExpressivity().hasCardinality()){
//update the queue so the max rule will be fired
updateQueueAddEdge(subj, pred, obj);
}
}
//merge again if necessary
if (!mergeList.isEmpty())
mergeAll();
//set appropriate branch
abox.setBranch(abox.getBranches().size() + 1);
// we will also need to add stuff to the queue in the event of a
// deletion
//Handle removed edges
Iterator<Edge> i = getRemovedEdgeIterator();
while( i.hasNext() ){
Edge e = i.next();
Individual subj = e.getFrom();
Node obj = e.getTo();
subj = subj.getSame();
subj.applyNext[Node.SOME] = 0;
subj.applyNext[Node.MIN] = 0;
QueueElement qe = new QueueElement( subj );
abox.getCompletionQueue().add( qe, NodeSelector.EXISTENTIAL );
abox.getCompletionQueue().add( qe, NodeSelector.MIN_NUMBER );
obj = obj.getSame();
if(obj instanceof Individual){
Individual objInd = (Individual)obj;
objInd.applyNext[Node.SOME] = 0;
objInd.applyNext[Node.MIN] = 0;
qe = new QueueElement( objInd );
abox.getCompletionQueue().add( qe, NodeSelector.EXISTENTIAL );
abox.getCompletionQueue().add( qe, NodeSelector.MIN_NUMBER );
}
}
//Handle removed types
Iterator<Map.Entry<Node,Set<ATermAppl>>> it = getRemovedTypeIterator();
while( it.hasNext() ){
Node node = it.next().getKey();
if( node.isIndividual() ){
Individual ind = (Individual)node;
//readd the conjunctions
readdConjunctions( ind );
//it could be the case that the type can be added from unfolding, a forAll application on a self loop, or the disjunction rule
ind.applyNext[Node.ATOM] = 0;
ind.applyNext[Node.ALL] = 0;
ind.applyNext[Node.OR] = 0;
QueueElement qe = new QueueElement( ind );
abox.getCompletionQueue().add( qe, NodeSelector.ATOM );
abox.getCompletionQueue().add( qe, NodeSelector.DISJUNCTION );
//fire the all rule as the is no explicit call to it
allValuesRule.apply( ind );
//get out edges and check domains, some values and min values
for( int j = 0; j < ind.getOutEdges().size(); j++ ){
Edge e = ind.getOutEdges().edgeAt( j );
if( e.getFrom().isPruned() || e.getTo().isPruned() )
continue;
Role pred = e.getRole();
Node obj = e.getTo();
DependencySet ds = e.getDepends();
for( ATermAppl domain : pred.getDomains() ) {
if( requiredAddType( ind, domain ) ) {
if( !PelletOptions.USE_TRACING )
addType( ind, domain, ds.union( DependencySet.EMPTY, abox.doExplanation() ) );
else
addType( ind, domain, ds.union( pred.getExplainDomain( domain ), abox.doExplanation() ) );
}
}
//it could be the case that this label prevented the firing of the all values, some, or min rules of the neighbor
if( obj instanceof Individual ){
Individual objInd = (Individual)obj;
objInd.applyNext[Node.ALL] = 0;
objInd.applyNext[Node.SOME] = 0;
objInd.applyNext[Node.MIN] = 0;
QueueElement qeObj = new QueueElement( objInd );
abox.getCompletionQueue().add( qeObj, NodeSelector.EXISTENTIAL );
abox.getCompletionQueue().add( qeObj, NodeSelector.MIN_NUMBER );
//apply the all values rule
allValuesRule.apply( ind );
}
}
}
//get out edges
for( int j = 0; j < node.getInEdges().size(); j++ ){
Edge e = node.getInEdges().edgeAt( j );
if( e.getFrom().isPruned() || e.getTo().isPruned() )
continue;
Individual subj = e.getFrom();
Role pred = e.getRole();
DependencySet ds = e.getDepends();
for( ATermAppl range : pred.getRanges() ) {
if( requiredAddType( node, range ) ) {
if( !PelletOptions.USE_TRACING )
addType( node, range, ds.union( DependencySet.EMPTY, abox.doExplanation() ) );
else
addType( node, range, ds.union( pred.getExplainRange( range ), abox.doExplanation() ) );
}
}
//it could be the case that this label prevented the firing of the all values, some, or min rules of the neighbor
subj.applyNext[Node.ALL] = 0;
subj.applyNext[Node.SOME] = 0;
subj.applyNext[Node.MIN] = 0;
QueueElement qe = new QueueElement( subj );
abox.getCompletionQueue().add( qe, NodeSelector.EXISTENTIAL );
abox.getCompletionQueue().add( qe, NodeSelector.MIN_NUMBER );
allValuesRule.apply( subj );
}
}
//due to unmerging nodes, edges can actually be added
i = getNewEdgeIterator();
while( i.hasNext() ){
applyPropertyRestrictions( i.next() );
}
//due to unmerging any node that was pruned could need rules applied to it. This is because these rules
//would have been originally applied to the node that the pruned node was merged into.
for(Iterator<Node> nodeIt = getUnPrunedIterator(); nodeIt.hasNext(); ) {
Node n = nodeIt.next();
if( n.isIndividual() ) {
Individual ind = (Individual) n;
//reset type pointers
for( int j = 0; j < Node.TYPES; j++ )
ind.applyNext[j] = 0;
//add to all queues
abox.getCompletionQueue().add( new QueueElement( ind ) );
allValuesRule.apply( ind );
//get out edges
for( int j = 0; j < ind.getOutEdges().size(); j++ ){
Edge e = ind.getOutEdges().edgeAt( j );
if( !e.getFrom().isPruned() && !e.getTo().isPruned() )
applyPropertyRestrictions( e );
Node obj = e.getTo();
if( obj instanceof Individual ){
Individual objInd = (Individual)obj;
objInd.applyNext[Node.ALL] = 0;
allValuesRule.apply( objInd );
}
}
//get out edges
for( int j = 0; j < ind.getInEdges().size(); j++ ){
Edge e = ind.getInEdges().edgeAt( j );
if( !e.getFrom().isPruned() && !e.getTo().isPruned() )
applyPropertyRestrictions( e );
Individual subj= e.getFrom();
subj.applyNext[Node.ALL] = 0;
allValuesRule.apply( subj );
}
}
}