public interface OWLReasoner
getRootOntology()
method. When the client responsible for
creating the reasoner has finished with the reasoner instance it must call
the dispose()
method to free any resources that are used by the
reasoner. In general, reasoners should not be instantiated directly, but
should be created using the appropriate
OWLReasonerFactory
. OWLOntologyManager
that manages the root
ontology. The reasoner will listen to any
OWLOntologyChange
s and respond
appropriately to them before answering any queries. If the
BufferingMode
of the reasoner (the
answer to getBufferingMode()
is
BufferingMode.NON_BUFFERING
) the
ontology changes are processed by the reasoner immediately so that any
queries asked after the changes are answered with respect to the changed
ontologies. If the BufferingMode
of
the reasoner is
BufferingMode.BUFFERING
then ontology
changes are stored in a buffer and are only taken into consideration when the
buffer is flushed with the flush()
method. When reasoning, axioms in
the root ontology imports closure, minus the axioms returned by the
getPendingAxiomAdditions()
method, plus the axioms returned by the
getPendingAxiomRemovals()
are taken into consideration. getPendingAxiomRemovals()
minus the axioms returned by getPendingAxiomAdditions()
NodeSet
s. These are sets of
Node
s. A Node
contains
entities. Node<OWLClass>
of classes, each class in the node is
equivalent to the other classes in the Node
with respect to the
imports closure of the root ontology. Node<OWLObjectProperty>
of object properties, each object
property in the Node
is equivalent to the other object properties in
the node with respect to the imports closure of the root ontology. Node<OWLDataProperty>
of data properties, each data
property in the Node
is equivalent to the other data properties in the
node with respect to the imports closure of the root ontology. Node<OWLNamedIndividual>
of named individuals, each
individual in the node is the same as the other individuals in the node with
respect to the imports closure of the root ontology. NodeSet
"contains" an entity if
that entity is contained in one of the Nodes
in the NodeSet
. Node
. In this case the top node contains
owl:Thing
and the bottom node contains owl:Nothing
because the
nodes in the hierarchy are OWLClass
nodes. In this case, class
G
is equivalent to owl:Thing
so it appears as an entity in the
top node along with owl:Thing
. Similarly, class K
is
unsatisfiable, so it is equivalent to owl:Nothing
, and therefore
appears in the bottom node containing owl:Nothing
. In this example,
classes A
and B
are equivalent so they appear in one node,
also, classes D
and F
are equivalent so they appear in one
node. NodeSet
containing the nodes that contain classes that are strict
subclasses of the specified class (expression). For example, asking for the
subclasses of class C
returns the NodeSet
{E}
and {owl:Nothing, K}
. NodeSet
that contains the nodes that contains classes that are direct
subclasses of the specified class. For example, asking for the direct
subclasses of class A
returns the NodeSet
containing the nodes
{C}
and {D, F}
. Note that there are
convenience methods on NodeSet
and
Node
that can be used to directly
access the entities in a NodeSet
without having to iterate over the
nodes and entities in a NodeSet
. For example, a "plain" set of classes
contained inside the Nodes
contained inside a NodeSet
can
easily be obtained using the NodeSet.getFlattened()
method. In this
case we could quickly obtain {C, D, F}
as the direct
subclasses of A
simply by using the
getSubClasses(org.semanticweb.owlapi.model.OWLClassExpression, boolean)
(with boolean=true) method on OWLReasoner
and then we could use the
NodeSet.getFlattened()
method on the retuned NodeSet
. Node
that contains classes that are equivalent to the class (expression) . For
example, asking for the equivalent classes of owl:Nothing
(i.e. asking
for the unsatisfiable classes) returns the Node
{owl:Nothing, K}
. CE1
and
CE2
and an ontology O
, CE1
is a strict subclass of
CE2
, written StrictSubClassOf(CE1 CE2)
if O
entails
SubClassOf(CE1 CE2)
and O
does not entail
SubClassOf(CE2 CE1)
CE1
and
CE2
and an ontology O
, CE1
is a direct subclass
of CE2
, written DirectSubClassOf(CE1 CE2)
, with respect to
O
if O
entails StrictSubClassOf(CE1 CE2)
and there is
no class name C
in the signature of O
such that O
entails StrictSubClassOf(CE1 C)
and O
entails
StrictSubClassOf(C CE2)
. OPE1
and OPE2
and an ontology O
, OPE1
is a
strict subproperty of OPE2
, written
StrictSubObjectPropertyOf(OPE1 OPE2)
if O
entails
SubObjectPropertyOf(OPE1 OPE2)
and O
does not entail
SubObjectPropertyOf(OPE2 OPE1)
OPE1
and OPE2
and an ontology O
, OPE1
is a
direct subproperty of OPE2
, written
DirectSubObjectPropertyOf(OPE1 OPE2)
, with respect to O
if
O
entails StrictSubObjectPropertyOf(OPE1 OPE2)
and there is no
object property name P
in the signature of O
such that
O
entails StrictSubObjectPropertyOf(OPE1 P)
and O
entails StrictSubObjectPropertyOf(P OPE2)
. DPE1
and DPE2
and an ontology O
, DPE1
is a
strict subproperty of DPE2
, written
StrictSubDataPropertyOf(DPE1 DPE2)
if O
entails
SubDataPropertyOf(DPE1 DPE2)
and O
does not entail
SubDataPropertyOf(DPE1 DPE2)
DPE1
and DPE2
and an ontology O
, DPE1
is a
direct subproperty of DPE2
, written
DirectSubDataPropertyOf(DPE1 DPE2)
, with respect to O
if
O
entails StrictSubDataPropertyOf(DPE1 DPE2)
and there is no
data property name P
in the signature of O
such that O
entails StrictSubDataPropertyOf(DPE1 P)
and O
entails
StrictSubDataPropertyOf(P DPE2)
. j
and a class
expression CE
and an ontology O
, CE
is a direct class
assertion (type) for j
, written DirectClassAssertion(CE j)
, if
O
entails ClassAssertion(CE j)
and there is no class name
C
in the signature of O
such that O
entails
ClassAssertion(C j)
and O
entails
StrictSubClassOf(C CE)
. pe
, the object property complement of
pe
is written as ObjectPropertyComplementOf(pe)
. The
interpretation of ObjectPropertyComplementOf(pe)
is equal to the
interpretation of owl:topObjectProperty
minus the interpretation of
pe
. In other words, ObjectPropertyComplementOf(pe)
is the set
of pairs of individuals that are not in pe
. pe
,
the data property complement of pe
is written as
DataPropertyComplementOf(pe)
. The interpretation of
DataPropertyComplementOf(pe)
is equal to the interpretation of
owl:topDataProperty
minus the interpretation of pe
. In other
words, DataPropertyComplementOf(pe)
is the set of pairs of individual
and literals that are not in pe
. P
, or an object inverse property of the form
ObjectInverseOf(P)
where P
is a named property. In other
words, there is no nesting of ObjectInverseOf
operators. OWLReasoner
may throw the following exceptions to
indicate errors. More documentation for each type of exception can be found
on the particular exception class.
AxiomNotInProfileException
ClassExpressionNotInProfileException
FreshEntitiesException
InconsistentOntologyException
TimeOutException
ReasonerInterruptedException
UnsupportedEntailmentTypeException
ReasonerInternalException
ReasonerInternalException
may be throw by any of the reasoner methods below.Modifier and Type | Method and Description |
---|---|
void |
dispose()
Disposes of this reasoner.
|
void |
flush()
Flushes any changes stored in the buffer, which causes the reasoner to
take into consideration the changes the current root ontology specified
by the changes.
|
Node<OWLClass> |
getBottomClassNode()
Gets the
Node corresponding to the bottom node (containing
owl:Nothing ) in the class hierarchy. |
Node<OWLDataProperty> |
getBottomDataPropertyNode()
Gets the
Node corresponding to the bottom node (containing
owl:bottomDataProperty ) in the data property hierarchy. |
Node<OWLObjectPropertyExpression> |
getBottomObjectPropertyNode()
Gets the
Node corresponding to the bottom node (containing
owl:bottomObjectProperty ) in the object property hierarchy. |
BufferingMode |
getBufferingMode()
Gets the buffering mode of this reasoner.
|
NodeSet<OWLClass> |
getDataPropertyDomains(OWLDataProperty pe,
boolean direct)
Gets the named classes that are the direct or indirect domains of this
property with respect to the imports closure of the root ontology.
|
Set<OWLLiteral> |
getDataPropertyValues(OWLNamedIndividual ind,
OWLDataProperty pe)
Gets the data property values for the specified individual and data
property expression.
|
NodeSet<OWLNamedIndividual> |
getDifferentIndividuals(OWLNamedIndividual ind)
Gets the individuals which are entailed to be different from the
specified individual.
|
NodeSet<OWLClass> |
getDisjointClasses(OWLClassExpression ce)
Gets the classes that are disjoint with the specified class expression
ce . |
NodeSet<OWLDataProperty> |
getDisjointDataProperties(OWLDataPropertyExpression pe)
Gets the data properties that are disjoint with the specified data
property expression
pe . |
NodeSet<OWLObjectPropertyExpression> |
getDisjointObjectProperties(OWLObjectPropertyExpression pe)
Gets the simplified object property expressions that
are disjoint with the specified object property expression
pe . |
Node<OWLClass> |
getEquivalentClasses(OWLClassExpression ce)
Gets the set of named classes that are equivalent to the specified class
expression with respect to the set of reasoner axioms.
|
Node<OWLDataProperty> |
getEquivalentDataProperties(OWLDataProperty pe)
Gets the set of named data properties that are equivalent to the
specified data property expression with respect to the imports closure of
the root ontology.
|
Node<OWLObjectPropertyExpression> |
getEquivalentObjectProperties(OWLObjectPropertyExpression pe)
Gets the set of simplified object property expressions
that are equivalent to the specified object property expression with
respect to the set of reasoner axioms.
|
FreshEntityPolicy |
getFreshEntityPolicy()
Gets the Fresh Entity Policy in use by this reasoner.
|
IndividualNodeSetPolicy |
getIndividualNodeSetPolicy()
Gets the IndividualNodeSetPolicy in use by this reasoner.
|
NodeSet<OWLNamedIndividual> |
getInstances(OWLClassExpression ce,
boolean direct)
Gets the individuals which are instances of the specified class
expression.
|
Node<OWLObjectPropertyExpression> |
getInverseObjectProperties(OWLObjectPropertyExpression pe)
Gets the set of simplified object property expressions
that are the inverses of the specified object property expression with
respect to the imports closure of the root ontology.
|
NodeSet<OWLClass> |
getObjectPropertyDomains(OWLObjectPropertyExpression pe,
boolean direct)
Gets the named classes that are the direct or indirect domains of this
property with respect to the imports closure of the root ontology.
|
NodeSet<OWLClass> |
getObjectPropertyRanges(OWLObjectPropertyExpression pe,
boolean direct)
Gets the named classes that are the direct or indirect ranges of this
property with respect to the imports closure of the root ontology.
|
NodeSet<OWLNamedIndividual> |
getObjectPropertyValues(OWLNamedIndividual ind,
OWLObjectPropertyExpression pe)
Gets the object property values for the specified individual and object
property expression.
|
Set<OWLAxiom> |
getPendingAxiomAdditions()
Gets the axioms that as a result of ontology changes need to be added to
the reasoner to synchronise it with the root ontology imports closure.
|
Set<OWLAxiom> |
getPendingAxiomRemovals()
Gets the axioms that as a result of ontology changes need to removed to
the reasoner to synchronise it with the root ontology imports closure.
|
List<OWLOntologyChange> |
getPendingChanges()
Gets the pending changes which need to be taken into consideration by the
reasoner so that it is up to date with the root ontology imports closure.
|
Set<InferenceType> |
getPrecomputableInferenceTypes()
Returns the set of
InferenceType s
that are precomputable by reasoner. |
String |
getReasonerName()
Gets the name of this reasoner.
|
Version |
getReasonerVersion()
Gets the version of this reasoner.
|
OWLOntology |
getRootOntology()
Gets the "root" ontology that is loaded into this reasoner.
|
Node<OWLNamedIndividual> |
getSameIndividuals(OWLNamedIndividual ind)
Gets the individuals that are the same as the specified individual.
|
NodeSet<OWLClass> |
getSubClasses(OWLClassExpression ce,
boolean direct)
Gets the set of named classes that are the strict (potentially direct)
subclasses of the specified class expression with respect to the reasoner
axioms.
|
NodeSet<OWLDataProperty> |
getSubDataProperties(OWLDataProperty pe,
boolean direct)
Gets the set of named data properties that are the strict (potentially
direct) subproperties of the specified data property expression with
respect to the imports closure of the root ontology.
|
NodeSet<OWLObjectPropertyExpression> |
getSubObjectProperties(OWLObjectPropertyExpression pe,
boolean direct)
Gets the set of simplified object property expressions
that are the strict (potentially direct) subproperties of the specified
object property expression with respect to the imports closure of the
root ontology.
|
NodeSet<OWLClass> |
getSuperClasses(OWLClassExpression ce,
boolean direct)
Gets the set of named classes that are the strict (potentially direct)
super classes of the specified class expression with respect to the
imports closure of the root ontology.
|
NodeSet<OWLDataProperty> |
getSuperDataProperties(OWLDataProperty pe,
boolean direct)
Gets the set of named data properties that are the strict (potentially
direct) super properties of the specified data property with respect to
the imports closure of the root ontology.
|
NodeSet<OWLObjectPropertyExpression> |
getSuperObjectProperties(OWLObjectPropertyExpression pe,
boolean direct)
Gets the set of simplified object property expressions
that are the strict (potentially direct) super properties of the
specified object property expression with respect to the imports closure
of the root ontology.
|
long |
getTimeOut()
Gets the time out (in milliseconds) for the most basic reasoning
operations.
|
Node<OWLClass> |
getTopClassNode()
Gets the
Node corresponding to the top node (containing
owl:Thing ) in the class hierarchy. |
Node<OWLDataProperty> |
getTopDataPropertyNode()
Gets the
Node corresponding to the top node (containing
owl:topDataProperty ) in the data property hierarchy. |
Node<OWLObjectPropertyExpression> |
getTopObjectPropertyNode()
Gets the
Node corresponding to the top node (containing
owl:topObjectProperty ) in the object property hierarchy. |
NodeSet<OWLClass> |
getTypes(OWLNamedIndividual ind,
boolean direct)
Gets the named classes which are (potentially direct) types of the
specified named individual.
|
Node<OWLClass> |
getUnsatisfiableClasses()
A convenience method that obtains the classes in the signature of the
root ontology that are unsatisfiable.
|
void |
interrupt()
Asks the reasoner to interrupt what it is currently doing.
|
boolean |
isConsistent()
Determines if the set of reasoner axioms is consistent.
|
boolean |
isEntailed(OWLAxiom axiom)
A convenience method that determines if the specified axiom is entailed
by the set of reasoner axioms.
|
boolean |
isEntailed(Set<? extends OWLAxiom> axioms)
Determines if the specified set of axioms is entailed by the reasoner
axioms.
|
boolean |
isEntailmentCheckingSupported(AxiomType<?> axiomType)
Determines if entailment checking for the specified axiom type is
supported.
|
boolean |
isPrecomputed(InferenceType inferenceType)
Determines if a specific set of inferences have been precomputed.
|
boolean |
isSatisfiable(OWLClassExpression classExpression)
A convenience method that determines if the specified class expression is
satisfiable with respect to the reasoner axioms.
|
void |
precomputeInferences(InferenceType... inferenceTypes)
Asks the reasoner to precompute certain types of inferences.
|
String getReasonerName()
Version getReasonerVersion()
null
.BufferingMode getBufferingMode()
void flush()
BufferingMode.NON_BUFFERING
then
this method will have no effect.List<OWLOntologyChange> getPendingChanges()
flush()
method is called the set of pending changes
will be empty.Set<OWLAxiom> getPendingAxiomAdditions()
BufferingMode.NON_BUFFERING
then
there will be no pending axiom additions.Set<OWLAxiom> getPendingAxiomRemovals()
BufferingMode.NON_BUFFERING
then
there will be no pending axiom additions.OWLOntology getRootOntology()
getPendingAxiomRemovals()
, minus the
axioms returned by getPendingAxiomAdditions()
when reasoning. void interrupt()
void precomputeInferences(InferenceType... inferenceTypes) throws ReasonerInterruptedException, TimeOutException, InconsistentOntologyException
SubClassOf(A B)
then the result of
getSubClasses(B)
will contain A
, regardless of whether
precomputeInferences( InferenceType#CLASS_HIERARCHY)
has been
called. inferenceTypes
- Suggests a list of the types of inferences that should be
precomputed. If the list is empty then the reasoner will determine
which types of inferences are precomputed. Note that the order of
the list is unimportant - the reasoner will determine the order in
which inferences are computed.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.boolean isPrecomputed(InferenceType inferenceType)
inferenceType
- The type of inference to check for.true
if the specified type of inferences have been
precomputed, otherwise false
.Set<InferenceType> getPrecomputableInferenceTypes()
InferenceType
s
that are precomputable by reasoner.InferenceType
s
that can be precomputed by this reasoner.boolean isConsistent() throws ReasonerInterruptedException, TimeOutException
InconsistentOntologyException
even if the root ontology imports closure is inconsistent.true
if the imports closure of the root ontology is
consistent, or false
if the imports closure of the root
ontology is inconsistent.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process).TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.boolean isSatisfiable(OWLClassExpression classExpression) throws ReasonerInterruptedException, TimeOutException, ClassExpressionNotInProfileException, FreshEntitiesException, InconsistentOntologyException
classExpression
- The class expressiontrue
if classExpression is satisfiable with respect to
the set of axioms, or false
if classExpression is
unsatisfiable with respect to the axioms.InconsistentOntologyException
- if the set of reasoner axioms is inconsistentClassExpressionNotInProfileException
- if classExpression
is not within the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the classExpression is not contained within
the signature of the set of reasoner axioms.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLClass> getUnsatisfiableClasses() throws ReasonerInterruptedException, TimeOutException, InconsistentOntologyException
Node
that is the bottom node in the class hierarchy.
This node represents owl:Nothing
and contains
owl:Nothing
itself plus classes that are equivalent to
owl:Nothing
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.InconsistentOntologyException
- if the set of reasoner axioms is inconsistentboolean isEntailed(OWLAxiom axiom) throws ReasonerInterruptedException, UnsupportedEntailmentTypeException, TimeOutException, AxiomNotInProfileException, FreshEntitiesException, InconsistentOntologyException
axiom
- The axiomtrue
if axiom
is entailed by the reasoner axioms
or false
if axiom
is not entailed by the reasoner
axioms. true
if the set of reasoner axioms is
inconsistent.FreshEntitiesException
- if the signature of the axiom is not contained within the
signature of the imports closure of the root ontology.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.UnsupportedEntailmentTypeException
- if the reasoner cannot perform a check to see if the specified
axiom is entailedAxiomNotInProfileException
- if axiom
is not in the profile that is supported by this
reasoner.InconsistentOntologyException
- if the set of reasoner axioms is inconsistentisEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)
boolean isEntailed(Set<? extends OWLAxiom> axioms) throws ReasonerInterruptedException, UnsupportedEntailmentTypeException, TimeOutException, AxiomNotInProfileException, FreshEntitiesException, InconsistentOntologyException
axioms
- The set of axioms to be testedtrue
if the set of axioms is entailed by the axioms in
the imports closure of the root ontology, otherwise false
. If the set of reasoner axioms is inconsistent then true
.FreshEntitiesException
- if the signature of the set of axioms is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.UnsupportedEntailmentTypeException
- if the reasoner cannot perform a check to see if the specified
axiom is entailedAxiomNotInProfileException
- if axiom
is not in the profile that is supported by this
reasoner.InconsistentOntologyException
- if the set of reasoner axioms is inconsistentisEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)
boolean isEntailmentCheckingSupported(AxiomType<?> axiomType)
axiomType
- The axiom typetrue
if entailment checking for the specified axiom type
is supported, otherwise false
. If true
then
asking isEntailed(org.semanticweb.owlapi.model.OWLAxiom)
will not throw an exception of
UnsupportedEntailmentTypeException
. If false
then asking
isEntailed(org.semanticweb.owlapi.model.OWLAxiom)
will throw an
UnsupportedEntailmentTypeException
.Node<OWLClass> getTopClassNode()
Node
corresponding to the top node (containing
owl:Thing
) in the class hierarchy.Node
containing owl:Thing
that is the top node
in the class hierarchy. This Node
is essentially equal to
the Node
returned by calling
getEquivalentClasses(org.semanticweb.owlapi.model.OWLClassExpression)
with a parameter of owl:Thing
.Node<OWLClass> getBottomClassNode()
Node
corresponding to the bottom node (containing
owl:Nothing
) in the class hierarchy.Node
containing owl:Nothing
that is the bottom
node in the class hierarchy. This Node
is essentially
equal to the Node
that will be returned by calling
getEquivalentClasses(org.semanticweb.owlapi.model.OWLClassExpression)
with a parameter of owl:Nothing
.NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct) throws ReasonerInterruptedException, TimeOutException, FreshEntitiesException, InconsistentOntologyException, ClassExpressionNotInProfileException
NodeSet
.ce
- The class expression whose strict (direct) subclasses are to be
retrieved.direct
- Specifies if the direct subclasses should be retrived (
true
) or if the all subclasses (descendant) classes should
be retrieved (false
).true
, a NodeSet
such that for each
class C
in the NodeSet
the set of reasoner axioms
entails DirectSubClassOf(C, ce)
. false
, a NodeSet
such that for each
class C
in the NodeSet
the set of reasoner axioms
entails StrictSubClassOf(C, ce)
. ce
is equivalent to owl:Nothing
then the empty
NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if classExpression
is not within the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the classExpression is not contained within
the signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.ce
- The class expression whose strict (direct) super classes are to be
retrieved.direct
- Specifies if the direct super classes should be retrived (
true
) or if the all super classes (ancestors) classes
should be retrieved (false
).true
, a NodeSet
such that for each
class C
in the NodeSet
the set of reasoner axioms
entails DirectSubClassOf(ce, C)
. false
, a NodeSet
such that for each
class C
in the NodeSet
the set of reasoner axioms
entails StrictSubClassOf(ce, C)
. ce
is equivalent to owl:Thing
then the empty
NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if classExpression
is not within the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the classExpression is not contained within
the signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLClass> getEquivalentClasses(OWLClassExpression ce) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
Node
.ce
- The class expression whose equivalent classes are to be retrieved.C
in the node the root ontology imports closure
entails EquivalentClasses(ce C)
. If ce
is not a
class name (i.e. it is an anonymous class expression) and there
are no such classes C
then the node will be empty. ce
is a named class then ce
will be contained
in the node. ce
is unsatisfiable with respect to the set of
reasoner axioms then the node representing and containing
owl:Nothing
, i.e. the bottom node, will be returned. ce
is equivalent to owl:Thing
with respect to
the set of reasoner axioms then the node representing and
containing owl:Thing
, i.e. the top node, will be returned InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if classExpression
is not within the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the classExpression is not contained within
the signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) throws ReasonerInterruptedException, TimeOutException, FreshEntitiesException, InconsistentOntologyException
ce
. The classes are returned as a
NodeSet
.ce
- The class expression whose disjoint classes are to be retrieved.NodeSet
such that for each class
D
in the NodeSet
the set of reasoner axioms
entails EquivalentClasses(D, ObjectComplementOf(ce))
or
StrictSubClassOf(D, ObjectComplementOf(ce))
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if classExpression
is not within the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the classExpression is not contained within
the signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLObjectPropertyExpression> getTopObjectPropertyNode()
Node
corresponding to the top node (containing
owl:topObjectProperty
) in the object property hierarchy.Node
containing owl:topObjectProperty
that is
the top node in the object property hierarchy. This Node
is essentially equivalent to the Node
returned by calling
getEquivalentObjectProperties(org.semanticweb.owlapi.model.OWLObjectPropertyExpression)
with a parameter of owl:topObjectProperty
.Node<OWLObjectPropertyExpression> getBottomObjectPropertyNode()
Node
corresponding to the bottom node (containing
owl:bottomObjectProperty
) in the object property hierarchy.Node
, containing owl:bottomObjectProperty
, that
is the bottom node in the object property hierarchy. This
Node
is essentially equal to the Node
that will
be returned by calling
getEquivalentObjectProperties(org.semanticweb.owlapi.model.OWLObjectPropertyExpression)
with a parameter of owl:bottomObjectProperty
.NodeSet<OWLObjectPropertyExpression> getSubObjectProperties(OWLObjectPropertyExpression pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The object property expression whose strict (direct) subproperties
are to be retrieved.direct
- Specifies if the direct subproperties should be retrived (
true
) or if the all subproperties (descendants) should be
retrieved (false
).true
, a NodeSet
of simplified object property expressions, such that
for each simplified object property
expression, P
, in the NodeSet
the set of
reasoner axioms entails DirectSubObjectPropertyOf(P, pe)
. false
, a NodeSet
of simplified object property expressions, such that
for each simplified object property
expression, P
, in the NodeSet
the set of
reasoner axioms entails StrictSubObjectPropertyOf(P, pe)
. pe
is equivalent to owl:bottomObjectProperty
then the empty NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLObjectPropertyExpression> getSuperObjectProperties(OWLObjectPropertyExpression pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The object property expression whose strict (direct) super
properties are to be retrieved.direct
- Specifies if the direct super properties should be retrived (
true
) or if the all super properties (ancestors) should be
retrieved (false
).true
, a NodeSet
of simplified object property expressions, such that
for each simplified object property
expression, P
, in the NodeSet
, the set of
reasoner axioms entails DirectSubObjectPropertyOf(pe, P)
. false
, a NodeSet
of simplified object property expressions, such that
for each simplified object property
expression, P
, in the NodeSet
, the set of
reasoner axioms entails StrictSubObjectPropertyOf(pe, P)
. pe
is equivalent to owl:topObjectProperty
then
the empty NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLObjectPropertyExpression> getEquivalentObjectProperties(OWLObjectPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
Node
.pe
- The object property expression whose equivalent properties are to
be retrieved.P
, in the node, the set
of reasoner axioms entails
EquivalentObjectProperties(pe P)
. pe
is a simplified object property
expression If pe
is unsatisfiable with respect to the
set of reasoner axioms then the node representing and containing
owl:bottomObjectProperty
, i.e. the bottom node, will be
returned. pe
is equivalent to owl:topObjectProperty
with
respect to the set of reasoner axioms then the node representing
and containing owl:topObjectProperty
, i.e. the top node,
will be returned InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLObjectPropertyExpression> getDisjointObjectProperties(OWLObjectPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
pe
. The
object properties are returned as a
NodeSet
.pe
- The object property expression whose disjoint object properties
are to be retrieved.NodeSet
of simplified object property expressions, such that
for each simplified object property
expression, P
, in the NodeSet
the set of
reasoner axioms entails
EquivalentObjectProperties(P, ObjectPropertyComplementOf(pe))
or
StrictSubObjectPropertyOf(P, ObjectPropertyComplementOf(pe))
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if object propertyExpression
is not within the profile
that is supported by this reasoner.FreshEntitiesException
- if the signature of pe
is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.and the undeclared entity
policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLObjectPropertyExpression> getInverseObjectProperties(OWLObjectPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
pe
- The property expression whose inverse properties are to be
retrieved.NodeSet
of simplified object property
expressions, such that for each simplified object property
expression P
in the nodes set, the set of reasoner axioms
entails InverseObjectProperties(pe, P)
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getObjectPropertyDomains(OWLObjectPropertyExpression pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The property expression whose domains are to be retrieved.direct
- Specifies if the direct domains should be retrieved ( true
), or if all domains should be retrieved ( false
).N = getEquivalentClasses(ObjectSomeValuesFrom(pe owl:Thing))
. direct
is true
: then if N
is not empty
then the return value is N
, else the return value is the
result of
getSuperClasses(ObjectSomeValuesFrom(pe owl:Thing), true)
. direct
is false
: then the result of
getSuperClasses(ObjectSomeValuesFrom(pe owl:Thing), false)
together with N
if N
is non-empty.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The property expression whose ranges are to be retrieved.direct
- Specifies if the direct ranges should be retrieved ( true
), or if all ranges should be retrieved ( false
).N = getEquivalentClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing))
. direct
is true
: then if N
is not empty
then the return value is N
, else the return value is the
result of
getSuperClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), true)
. direct
is false
: then the result of
getSuperClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), false)
together with N
if N
is non-empty.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLDataProperty> getTopDataPropertyNode()
Node
corresponding to the top node (containing
owl:topDataProperty
) in the data property hierarchy.Node
, containing owl:topDataProperty
, that is
the top node in the data property hierarchy. This Node
is
essentially equal to the Node
returned by calling
getEquivalentDataProperties(org.semanticweb.owlapi.model.OWLDataProperty)
with a parameter of owl:topDataProperty
.Node<OWLDataProperty> getBottomDataPropertyNode()
Node
corresponding to the bottom node (containing
owl:bottomDataProperty
) in the data property hierarchy.Node
, containing owl:bottomDataProperty
, that
is the bottom node in the data property hierarchy. This
Node
is essentially equal to the Node
that will
be returned by calling
getEquivalentDataProperties(org.semanticweb.owlapi.model.OWLDataProperty)
with a parameter of owl:bottomDataProperty
.NodeSet<OWLDataProperty> getSubDataProperties(OWLDataProperty pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The data property whose strict (direct) subproperties are to be
retrieved.direct
- Specifies if the direct subproperties should be retrived (
true
) or if the all subproperties (descendants) should be
retrieved (false
).true
, a NodeSet
such that for each
property P
in the NodeSet
the set of reasoner
axioms entails DirectSubDataPropertyOf(P, pe)
. false
, a NodeSet
such that for each
property P
in the NodeSet
the set of reasoner
axioms entails StrictSubDataPropertyOf(P, pe)
. pe
is equivalent to owl:bottomDataProperty
then the empty NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the data property is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLDataProperty> getSuperDataProperties(OWLDataProperty pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The data property whose strict (direct) super properties are to be
retrieved.direct
- Specifies if the direct super properties should be retrived (
true
) or if the all super properties (ancestors) should be
retrieved (false
).true
, a NodeSet
such that for each
property P
in the NodeSet
the set of reasoner
axioms entails DirectSubDataPropertyOf(pe, P)
. false
, a NodeSet
such that for each
property P
in the NodeSet
the set of reasoner
axioms entails StrictSubDataPropertyOf(pe, P)
. pe
is equivalent to owl:topDataProperty
then
the empty NodeSet
will be returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the data property is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.Node<OWLDataProperty> getEquivalentDataProperties(OWLDataProperty pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
Node
.pe
- The data property expression whose equivalent properties are to be
retrieved.P
in the node, the set of reasoner
axioms entails EquivalentDataProperties(pe P)
. pe
is a named data property then pe
will be
contained in the node. pe
is unsatisfiable with respect to the set of
reasoner axioms then the node representing and containing
owl:bottomDataProperty
, i.e. the bottom node, will be
returned. ce
is equivalent to owl:topDataProperty
with
respect to the set of reasoner axioms then the node representing
and containing owl:topDataProperty
, i.e. the top node,
will be returned InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the data property expression is not contained
within the signature of the imports closure of the root ontology
and the undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLDataProperty> getDisjointDataProperties(OWLDataPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
pe
. The data properties are returned as a
NodeSet
.pe
- The data property expression whose disjoint data properties are to
be retrieved.NodeSet
such that for each data
property P
in the NodeSet
the set of reasoner
axioms entails
EquivalentDataProperties(P, DataPropertyComplementOf(pe))
or
StrictSubDataPropertyOf(P, DataPropertyComplementOf(pe))
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if data propertyExpression
is not within the profile that
is supported by this reasoner.FreshEntitiesException
- if the signature of pe
is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getDataPropertyDomains(OWLDataProperty pe, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.pe
- The property expression whose domains are to be retrieved.direct
- Specifies if the direct domains should be retrieved ( true
), or if all domains should be retrieved ( false
).N = getEquivalentClasses(DataSomeValuesFrom(pe rdfs:Literal))
. direct
is true
: then if N
is not empty
then the return value is N
, else the return value is the
result of
getSuperClasses(DataSomeValuesFrom(pe rdfs:Literal), true)
. direct
is false
: then the result of
getSuperClasses(DataSomeValuesFrom(pe rdfs:Literal), false)
together with N
if N
is non-empty. rdfs:Literal
is the top datatype).InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the object property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLClass> getTypes(OWLNamedIndividual ind, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.ind
- The individual whose types are to be retrieved.direct
- Specifies if the direct types should be retrieved ( true
),
or if all types should be retrieved ( false
).direct
is true
, a NodeSet
containing
named classes such that for each named class C
in the
node set, the set of reasoner axioms entails
DirectClassAssertion(C, ind)
. direct
is false
, a NodeSet
containing
named classes such that for each named class C
in the
node set, the set of reasoner axioms entails
ClassAssertion(C, ind)
. InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the individual is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.ce
- The class expression whose instances are to be retrieved.direct
- Specifies if the direct instances should be retrieved (
true
), or if all instances should be retrieved (
false
).direct
is true
, a NodeSet
containing
named individuals such that for each named individual j
in the node set, the set of reasoner axioms entails
DirectClassAssertion(ce, j)
. direct
is false
, a NodeSet
containing
named individuals such that for each named individual j
in the node set, the set of reasoner axioms entails
ClassAssertion(ce, j)
. NodeSet
is returned.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentClassExpressionNotInProfileException
- if the class expression ce
is not in the profile that is
supported by this reasoner.FreshEntitiesException
- if the signature of the class expression is not contained within
the signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.IndividualNodeSetPolicy
NodeSet<OWLNamedIndividual> getObjectPropertyValues(OWLNamedIndividual ind, OWLObjectPropertyExpression pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.ind
- The individual that is the subject of the object property valuespe
- The object property expression whose values are to be retrieved
for the specified individualNodeSet
containing named individuals such that for each
individual j
in the node set, the set of reasoner axioms
entails ObjectPropertyAssertion(pe ind j)
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the individual and property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.IndividualNodeSetPolicy
Set<OWLLiteral> getDataPropertyValues(OWLNamedIndividual ind, OWLDataProperty pe) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
ind
- The individual that is the subject of the data property valuespe
- The data property expression whose values are to be retrieved for
the specified individualOWLLiteral
s containing literals such that for
each literal l
in the set, the set of reasoner axioms
entails DataPropertyAssertion(pe ind l)
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the individual and property expression is not
contained within the signature of the imports closure of the root
ontology and the undeclared entity policy of this reasoner is set
to FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.IndividualNodeSetPolicy
Node<OWLNamedIndividual> getSameIndividuals(OWLNamedIndividual ind) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
ind
- The individual whose same individuals are to be retrieved.j
in the node, the root ontology imports closure entails
SameIndividual(j, ind)
. Note that the node will contain
j
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the individual is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual ind) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException
NodeSet
.ind
- The individual whose different individuals are to be returned.NodeSet
containing OWLNamedIndividual
s such
that for each individual i
in the NodeSet
the set
of reasoner axioms entails DifferentIndividuals(ind, i)
.InconsistentOntologyException
- if the imports closure of the root ontology is inconsistentFreshEntitiesException
- if the signature of the individual is not contained within the
signature of the imports closure of the root ontology and the
undeclared entity policy of this reasoner is set to
FreshEntityPolicy.DISALLOW
.ReasonerInterruptedException
- if the reasoning process was interrupted for any particular
reason (for example if reasoning was cancelled by a client
process)TimeOutException
- if the reasoner timed out during a basic reasoning operation. See
getTimeOut()
.long getTimeOut()
TimeOutException
in
the thread that is executing the reasoning process. interrupt()
method.Long.MAX_VALUE
.FreshEntityPolicy getFreshEntityPolicy()
IndividualNodeSetPolicy getIndividualNodeSetPolicy()
void dispose()
OWLOntologyChangeListener
from the
OWLOntologyManager
that manages the
ontologies contained within the reasoner.Copyright © 2017 The University of Manchester. All Rights Reserved.