Java FreshEntitiesException类代码示例

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public NodeSet<OWLDataProperty> getDisjointDataProperties(
		OWLDataPropertyExpression arg0)
		throws InconsistentOntologyException, FreshEntitiesException,
		ReasonerInterruptedException, TimeOutException {
	LOGGER_.trace("getDisjointDataProperties(OWLDataPropertyExpression)");

	checkInterrupted();
	// TODO Provide implementation
	throw unsupportedOwlApiMethod(
			"getDisjointDataProperties(OWLDataPropertyExpression)");
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
/**
 * note that this is not a standard reasoner method
 * 
 * @param ce
 * @param direct
 * @return all superclasses, where superclasses can include anon class expressions
 * @throws InconsistentOntologyException
 * @throws ClassExpressionNotInProfileException
 * @throws FreshEntitiesException
 * @throws ReasonerInterruptedException
 * @throws TimeOutException
 */
public Set<OWLClassExpression> getSuperClassExpressions(OWLClassExpression ce,
		boolean direct) throws InconsistentOntologyException,
		ClassExpressionNotInProfileException, FreshEntitiesException,
		ReasonerInterruptedException, TimeOutException {

	Set<OWLClassExpression> result = new HashSet<OWLClassExpression>();
	Set<OWLObject> supers = gw.getSubsumersFromClosure(ce);
	for (OWLObject sup : supers) {
		if (sup instanceof OWLClassExpression) {
			result.add((OWLClassExpression) sup);
		}
		else {

		}
	}
	return result;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce,
		boolean direct) throws InconsistentOntologyException,
		ClassExpressionNotInProfileException, FreshEntitiesException,
		ReasonerInterruptedException, TimeOutException {

	DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
	Set<OWLObject> supers = gw.getSubsumersFromClosure(ce);
	for (OWLObject sup : supers) {
		if (sup instanceof OWLClassExpression) {
			if (sup instanceof OWLClass) {
				result.addEntity((OWLClass) sup);
			}
			else {

			}
		}
		else {

		}
	}
	return result;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression ce,
		boolean direct) throws InconsistentOntologyException,
		ClassExpressionNotInProfileException, FreshEntitiesException,
		ReasonerInterruptedException, TimeOutException {
	DefaultNodeSet<OWLNamedIndividual> result = new OWLNamedIndividualNodeSet();
	Set<OWLObject> subs = gw.queryDescendants(ce, true, true);
	for (OWLObject s : subs) {
		if (s instanceof OWLNamedIndividual) {
			result.addEntity((OWLNamedIndividual) s);
		}
		else {

		}
	}
	return result;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
protected Set<OWLClass> findAncestors(String expr, 
		OWLObjectProperty p, boolean direct, Integer numExpected) throws TimeOutException, FreshEntitiesException, InconsistentOntologyException, ClassExpressionNotInProfileException, ReasonerInterruptedException, OWLParserException {
	System.out.println("Query: "+expr+" "+p+" Direct="+direct);
	OWLClassExpression qc = parseOMN(expr);
	System.out.println("QueryC: "+qc);
	//Set<OWLClassExpression> ces = reasoner.getSuperClassExpressions(qc, false);
	//System.out.println("NumX:"+ces.size());
	Set<OWLClass> clzs = reasoner.getSuperClassesOver(qc, p, direct);
	System.out.println("NumD:"+clzs.size());
	for (OWLClass c : clzs) {
		System.out.println("  D:"+c);
	}
	if (numExpected != null) {
		assertEquals(numExpected.intValue(), clzs.size());
	}
	return clzs;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public NodeSet<OWLObjectPropertyExpression> getDisjointObjectProperties(
		OWLObjectPropertyExpression objectPropertyExpression) throws InconsistentOntologyException,
		FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
	Objects.requireNonNull(objectPropertyExpression);
	logger.finer("getDisjointDataProperties(" + objectPropertyExpression + ")");
	NodeSet<OWLObjectPropertyExpression> ret = getTranslator().translateSSOPE(
			getReasoner().getDisjointObjectProperties(getTranslator().translateOPE(objectPropertyExpression)));
	logger.finer("" + ret);
	return ret;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public boolean isEntailed(Set<? extends OWLAxiom> axioms) throws ReasonerInterruptedException, UnsupportedEntailmentTypeException, TimeOutException, AxiomNotInProfileException, FreshEntitiesException, InconsistentOntologyException {
    for (OWLAxiom ax : axioms) {
        if (!getRootOntology().containsAxiomIgnoreAnnotations(ax, true)) {
            return false;
        }
    }
    return true;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    OWLClassNodeSet ns = new OWLClassNodeSet();
    if (!ce.isAnonymous()) {
        ensurePrepared();
        return classHierarchyInfo.getNodeHierarchyChildren(ce.asOWLClass(), direct, ns);
    }
    return ns;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    OWLClassNodeSet ns = new OWLClassNodeSet();
    if (!ce.isAnonymous()) {
        ensurePrepared();
        return classHierarchyInfo.getNodeHierarchyParents(ce.asOWLClass(), direct, ns);
    }
    return ns;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression objectPropertyExpression,
		boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException,
		TimeOutException {
	Objects.requireNonNull(objectPropertyExpression);
	logger.finer("getObjectPropertyRanges(" + objectPropertyExpression + ", " + direct + ")");
	throw new UnsupportedReasonerOperationInBornException(
			"Unsupported operation : getObjectPropertyRanges(OWLObjectPropertyExpression, boolean)");
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public NodeSet<OWLClass> getTypes(OWLNamedIndividual individual, boolean direct)
		throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException,
		TimeOutException {
	Objects.requireNonNull(individual);
	logger.finer("getTypes(" + individual + ", " + direct + ")");
	throw new UnsupportedReasonerOperationInBornException(
			"Unsupported operation : getTypes(OWLNamedIndividual, boolean)");
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public NodeSet<OWLNamedIndividual> getObjectPropertyValues(OWLNamedIndividual individual,
		OWLObjectPropertyExpression objectPropertyExpression) throws InconsistentOntologyException,
		FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
	Objects.requireNonNull(individual);
	Objects.requireNonNull(objectPropertyExpression);
	logger.finer("getObjectPropertyValues(" + individual + ", " + objectPropertyExpression + ")");
	throw new UnsupportedReasonerOperationInBornException(
			"Unsupported operation :  getObjectPropertyValues(OWLNamedIndividual)");
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLDataProperty> getDisjointDataProperties(OWLDataPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLDataProperty> result = new OWLDataPropertyNodeSet();
    for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
        for (OWLDisjointDataPropertiesAxiom axiom : ontology.getDisjointDataPropertiesAxioms(pe.asOWLDataProperty())) {
            for (OWLDataPropertyExpression dpe : axiom.getPropertiesMinus(pe)) {
                if (!dpe.isAnonymous()) {
                    result.addNode(dataPropertyHierarchyInfo.getEquivalents(dpe.asOWLDataProperty()));
                    result.addAllNodes(getSubDataProperties(dpe.asOWLDataProperty(), false).getNodes());
                }
            }
        }
    }
    return result;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
public NodeSet<OWLClass> getDataPropertyDomains(OWLDataProperty pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
    for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
        for (OWLDataPropertyDomainAxiom axiom : ontology.getDataPropertyDomainAxioms(pe)) {
            result.addNode(getEquivalentClasses(axiom.getDomain()));
            if (!direct) {
                result.addAllNodes(getSuperClasses(axiom.getDomain(), false).getNodes());
            }
        }
    }
    return result;
}
 

import org.semanticweb.owlapi.reasoner.FreshEntitiesException; //导入依赖的package包/类
@Override
public boolean isEntailed(OWLAxiom axiom) throws ReasonerInterruptedException, UnsupportedEntailmentTypeException,
		TimeOutException, AxiomNotInProfileException, FreshEntitiesException {
	Objects.requireNonNull(axiom);
	logger.finer("isEntailed((OWLAxiom) " + axiom + ")");
	boolean ret = getReasoner().isEntailed(getTranslator().translateSA(Collections.singleton(axiom)));
	logger.finer("" + ret);
	return ret;
}