Java OWLClassExpression.isOWLNothing方法代码示例

import org.semanticweb.owlapi.model.OWLClassExpression; //导入方法依赖的package包/类
/**
 * Checks whether a class expression is a subclass of another class expression.
 * @param subClassExpr class expression on the left-hand side 
 * @param superClassExpr class expression on the right-hand side
 * @return <code>true</code> if the class expression on the left-hand side is a subclass of the class expression
 * on the right-hand side, <code>false</code> otherwise
 */
protected boolean isSubClassOf(OWLClassExpression subClassExpr, OWLClassExpression superClassExpr) {
	boolean ret = subClassExpr.isOWLNothing() || superClassExpr.isOWLThing() || subClassExpr.equals(superClassExpr);
	if (!ret) {
		OWLSubClassOfAxiom axiom = getReasoner().getRootOntology().
			getOWLOntologyManager().getOWLDataFactory().getOWLSubClassOfAxiom(subClassExpr, superClassExpr);
		if (!getReasoner().isEntailmentCheckingSupported(axiom.getAxiomType())){
			throw new RuntimeException("ERROR : Entailment not supported by reasoner '" + getReasoner().getReasonerName() + "'.");
		}
		ret = getReasoner().isEntailed(axiom);
	}
	return ret;
}
 

import org.semanticweb.owlapi.model.OWLClassExpression; //导入方法依赖的package包/类
public OWLClassExpression visit(OWLObjectIntersectionOf d) {
    Set<OWLClassExpression> newConjuncts=new HashSet<OWLClassExpression>();
    for (OWLClassExpression description : d.getOperands()) {
        OWLClassExpression descriptionSimplified=getSimplified(description);
        if (descriptionSimplified.isOWLThing())
            continue;
        else if (descriptionSimplified.isOWLNothing())
            return m_factory.getOWLNothing();
        else if (descriptionSimplified instanceof OWLObjectIntersectionOf)
            newConjuncts.addAll(((OWLObjectIntersectionOf)descriptionSimplified).getOperands());
        else
            newConjuncts.add(descriptionSimplified);
    }
    return m_factory.getOWLObjectIntersectionOf(newConjuncts);
}
 

import org.semanticweb.owlapi.model.OWLClassExpression; //导入方法依赖的package包/类
public OWLClassExpression visit(OWLObjectSomeValuesFrom d) {
    OWLClassExpression filler=getSimplified(d.getFiller());
    if (filler.isOWLNothing())
        return m_factory.getOWLNothing();
    else
        return m_factory.getOWLObjectSomeValuesFrom(d.getProperty().getSimplified(),filler);
}
 

import org.semanticweb.owlapi.model.OWLClassExpression; //导入方法依赖的package包/类
public Node<OWLClass> getEquivalentClasses(OWLClassExpression queryClassExpression) {
	classifyClasses();
	if (queryClassExpression.isOWLNothing()) {
           return getBottomClassNode();
       } else if (queryClassExpression.isOWLThing()) {
       	return getTopClassNode();
       } else if (queryClassExpression instanceof OWLClass ){
       	OWLClass queryClass = (OWLClass) queryClassExpression;
       	return owlClassHierarchyNodeToNode(classHierarchy.getNodeForElement(queryClass));
       }
	// not supported yet
	return new OWLClassNode();
}
 

import org.semanticweb.owlapi.model.OWLClassExpression; //导入方法依赖的package包/类
/**
 * Search for the first class with a matching equivalent class definition. 
 * 
 * @param c
 * @param genus
 * @param relation
 * @return match or null
 */
private OWLClass hasMatchingIntersection(OWLClass c, OWLClass genus, OWLObjectProperty relation) {
	for(OWLOntology o : allOntologies) {
		Set<OWLEquivalentClassesAxiom> eqAxioms = o.getEquivalentClassesAxioms(c);
		for (OWLEquivalentClassesAxiom eqAxiom : eqAxioms) {
			Set<OWLClassExpression> expressions = eqAxiom.getClassExpressionsMinus(c);
			for (OWLClassExpression expression : expressions) {
				if (expression instanceof OWLObjectIntersectionOf) {
					OWLObjectIntersectionOf intersection = (OWLObjectIntersectionOf) expression;
					OWLClass differentiaCls = null;
					boolean matchesGenus = false;
					boolean matchesRelation = false;
					Set<OWLClassExpression> operands = intersection.getOperands();
					if (operands.size() == 2) {
						for (OWLClassExpression operand : operands) {
							if (operand.isAnonymous() == false) {
								OWLClass currentGenus = operand.asOWLClass();
								if (genus.equals(currentGenus)) {
									matchesGenus = true;
								}
							}
							else if (operand instanceof OWLObjectSomeValuesFrom) {
								OWLObjectSomeValuesFrom differentia = (OWLObjectSomeValuesFrom) operand;
								if (relation.equals(differentia.getProperty())) {
									matchesRelation = true;
									OWLClassExpression filler = differentia.getFiller();
									if (!filler.isAnonymous() && !filler.isOWLNothing() && !filler.isOWLThing()) {
										differentiaCls = filler.asOWLClass();
									}
								}
							}
						}
						if (matchesGenus && matchesRelation ) {
							 return differentiaCls;
						}
					}
				}
			}
		}
	}
	return null;
}