Overview | Package | Class | Tree | Deprecated | Index | Help
| Protégé-OWL 3.4 rc2
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.stanford.smi.protegex.owl.inference.reasoner
Interface ProtegeReasoner

All Superinterfaces:
  edu.stanford.smi.protege.util.Disposable

All Known Subinterfaces:
  ProtegeDIGReasoner

All Known Implementing Classes:
  AbstractProtegeReasoner, DefaultProtegeDIGReasoner

    public interface ProtegeReasoner

extends edu.stanford.smi.protege.util.Disposable

Method Summary
`void` | `classifyTaxonomy()` For each named class in the ontology, this method queries the reasoner for the consistency of the class, its inferred super classes and its inferred equivalent classes.
`void` | `computeEquivalentConcepts()` This method queries the reasoner the equivalent classes for each class in the ontology, and updates protege-owl with the information.
`void` | `computeInconsistentConcepts()` This method queries the reasoner for the consistency of all classes in the ontology, and updates protege-owl with the information.
`void` | `computeInferredHierarchy()` For each named class in the ontology, this method queries the reasoner to obtain its inferred superclasses.
`void` | `computeInferredIndividualTypes()` This method queries the reasoner for the types of all individuals in the ontology, and updates protege-owl with the information.
`void` | `forceReasonerReSynchronization()` Depending on the implementation of the ProtegeGenericReasoner, some kind of caching may be used.
`Collection<OWLClass>` | `getAncestorClasses(OWLClass aClass)` Gets the inferred ancestor classes of the specified class.
`Collection<OWLProperty>` | `getAncestorProperties(OWLProperty property)`
`Collection<OWLClass>` | `getDescendantClasses(OWLClass aClass)` Gets the inferred descendant classes of the specified class.
`Collection<OWLProperty>` | `getDescendantProperties(OWLProperty property)`
`Collection<OWLClass>` | `getEquivalentClasses(OWLClass aClass)` Gets the equivalent classes of the specified class.
`Collection<OWLClass>` | `getIndividualDirectTypes(OWLIndividual individual)` Get the direct inferred types for the specified individual.
`Collection<OWLIndividual>` | `getIndividualsBelongingToClass(OWLClass aClass)` Gets the individuals that are inferred to be members of the specified class.
`Collection<OWLClass>` | `getIndividualTypes(OWLIndividual individual)` Get the inferred types (direct and indirect) for the specified individual.
`OWLModel` | `getOWLModel()` Returns the OWL model to which this reasoner is attached to.
`ReasonerTaskListener` | `getReasonerTaskListener()`
`Collection<OWLIndividual>` | `getRelatedIndividuals(OWLIndividual subject, OWLObjectProperty objectProperty)` Get the individuals that are related to the `subject` individual through the object property `objectProperty`.
`Collection` | `getRelatedValues(OWLIndividual subject, OWLDatatypeProperty datatypeProperty)` Get the values that are related to the `subject` individual through the datatype property `datatypeProperty`.
`Collection<OWLClass>` | `getSubclasses(OWLClass aClass)` Gets the (direct) inferred subclasses of the specified class.
`Collection<OWLProperty>` | `getSubProperties(OWLProperty property)`
`Collection<OWLClass>` | `getSuperclasses(OWLClass aClass)` Gets the (direct) inferred superclasses of the specified class.
`Collection<OWLProperty>` | `getSuperProperties(OWLProperty property)`
`void` | `initialize()` This is an optional method that can be called by applications and that gives the reasoner a chance to do some pre-computations.
`boolean` | `isAutoSynchronizationEnabled()`
`boolean` | `isDisjointTo(OWLClass cls1, OWLClass cls2)` Determines if the specified classes are disjoint from each other.
`boolean` | `isIntersectionSatisfiable(OWLClass[] clses)` Determines if the intersection of the list of specified classes is satisfiable.
`boolean` | `isSatisfiable(OWLClass aClass)` This method queries the reasoner to determine if the specified concept is satisfiable.
`boolean` | `isSubsumedBy(OWLClass cls1, OWLClass cls2)` Determines if one class (cls1) is subsumed by another class (cls2).
`void` | `rebind()` Resynchronizes the reasoner with the OWL model.
`void` | `reset()` Detaches the OWL model from this reasoner, clears internal caches, and releases the resources allocated by this reasoner for the previously attached OWL model.
`void` | `setAutoSynchronizationEnabled(boolean b)` Depending on the implementation of the ProtegeOWLReasoner, the DIG reasoner may automatically be sunchronized with changes in the Protege-OWL knowledgebase.
`void` | `setOWLModel(OWLModel owlModel)` Sets the OWL model that will be attached to this reasoner.
`void` | `setReasonerTaskListener(ReasonerTaskListener reasonerTaskListener)` Set the listener which will be informed of the progress of the reasoning task.

Methods inherited from interface edu.stanford.smi.protege.util.Disposable
`dispose`

Method Detail

### getOWLModel

    OWLModel getOWLModel()

  Returns the OWL model to which this reasoner is attached to.

### setOWLModel

    void setOWLModel(OWLModel owlModel)

  Sets the OWL model that will be attached to this reasoner. The reasoner may do in this method a clean-up of the previously attached OWL model.

  Parameters:
    `owlModel` -

### initialize

    void initialize()

  This is an optional method that can be called by applications and that gives the reasoner a chance to do some pre-computations.

### reset

    void reset()

  Detaches the OWL model from this reasoner, clears internal caches, and releases the resources allocated by this reasoner for the previously attached OWL model. resources allocated

### rebind

    void rebind()

  Resynchronizes the reasoner with the OWL model. This usually implies a reset and a reload of the entire OWL model and can be an expensive operation. This is a useful method if the OWL model has changed, but the reasoner is not aware of the changes.

### computeInferredHierarchy

    void computeInferredHierarchy()
                                  throws ProtegeReasonerException

  For each named class in the ontology, this method queries the reasoner to obtain its inferred superclasses. This information is then pieced together to form the inferred hierarchy. The method updates the protege-owl structures that hold information about inferred superclasses, which means that methods such as `getInferredSuperClasses` on `RDFSClass` will return meaningful results.

  Throws:
    `ProtegeReasonerException`

### computeInconsistentConcepts

    void computeInconsistentConcepts()
                                     throws ProtegeReasonerException

  This method queries the reasoner for the consistency of all classes in the ontology, and updates protege-owl with the information.

  Throws:
    `ProtegeReasonerException`

### computeInferredIndividualTypes

    void computeInferredIndividualTypes()
                                        throws ProtegeReasonerException

  This method queries the reasoner for the types of all individuals in the ontology, and updates protege-owl with the information.

  Throws:
    `ProtegeReasonerException`

### computeEquivalentConcepts

    void computeEquivalentConcepts()
                                   throws ProtegeReasonerException

  This method queries the reasoner the equivalent classes for each class in the ontology, and updates protege-owl with the information.

  Throws:
    `ProtegeReasonerException`

### classifyTaxonomy

    void classifyTaxonomy()
                          throws ProtegeReasonerException

  For each named class in the ontology, this method queries the reasoner for the consistency of the class, its inferred super classes and its inferred equivalent classes. The method updates the protege-owl structures that hold this information, meaning that methods on `RDFSClass` such as `getInferredSuperClasses` will return meaningful results.

  Throws:
    `ProtegeReasonerException`

### isSatisfiable

    boolean isSatisfiable(OWLClass aClass)
                          throws ProtegeReasonerException

  This method queries the reasoner to determine if the specified concept is satisfiable.

  Parameters:
    `aClass` - The `OWLClass` whose satisfiablity is to be determined.
  Returns:
    `true` if the specified class is satisfiable (consistent) , or `false` if the specified class is not satisfiable (not consistent).
  Throws:
    `ProtegeReasonerException`

### isIntersectionSatisfiable

    boolean isIntersectionSatisfiable(OWLClass[] clses)
                                      throws ProtegeReasonerException

  Determines if the intersection of the list of specified classes is satisfiable.

  Parameters:
    `clses` - An array of `OWLClass`es, of which the satisfiablity of the intersection will be determined.
  Returns:
    `true` if the intersection of the list of classes is satisfiable (consistent) or `false` if the intersection of the list of classes is not satisfiable (not consistent)
  Throws:
    `ProtegeReasonerException`

### isSubsumedBy

    boolean isSubsumedBy(OWLClass cls1,
                         OWLClass cls2)
                         throws ProtegeReasonerException

  Determines if one class (cls1) is subsumed by another class (cls2). In other words, determines if cls2 is a superclass of cls1.

  Parameters:
    `cls1` - The subsumee (the expected subclass)
    `cls2` - The subsumer (the expected superclass)
  Returns:
    `true` if cls1 is subsumed by cls2, or `false` if cls1 is not subsumed by cls2.
  Throws:
    `ProtegeReasonerException`

### isDisjointTo

    boolean isDisjointTo(OWLClass cls1,
                         OWLClass cls2)
                         throws ProtegeReasonerException

  Determines if the specified classes are disjoint from each other. Note that because disjointedness is a symmetric property, the order of the specified classes does not matter.

  Parameters:
    `cls1` - An `OWLClass`
    `cls2` - An `OWLClass`
  Returns:
    `true` if cls1 is disjoint with cls2.
  Throws:
    `ProtegeReasonerException`

### getSuperclasses

    Collection<OWLClass> getSuperclasses(OWLClass aClass)
                                         throws ProtegeReasonerException

  Gets the (direct) inferred superclasses of the specified class.

  Parameters:
    `aClass` - The class whose inferred superclasses are to be retrieved.
  Returns:
    A `Collection` containing the classes that are the inferred superclasses of the specified class.
  Throws:
    `ProtegeReasonerException`

### getSubclasses

    Collection<OWLClass> getSubclasses(OWLClass aClass)
                                       throws ProtegeReasonerException

  Gets the (direct) inferred subclasses of the specified class.

  Parameters:
    `aClass` - The class whose inferred subclasses are to be retrieved.
  Returns:
    A `Collection` containing the inferred subclasses of the specified class.
  Throws:
    `ProtegeReasonerException`

### getAncestorClasses

    Collection<OWLClass> getAncestorClasses(OWLClass aClass)
                                            throws ProtegeReasonerException

  Gets the inferred ancestor classes of the specified class. The inferred ancestor classes is equivalent to the transitive closure of the inferred superclasses.

  Parameters:
    `aClass` - The class whose inferred ancestor classes are to be retrieved.
  Returns:
    A `Collection` containing the inferred ancestor classes of the specified class.
  Throws:
    `ProtegeReasonerException`

### getDescendantClasses

    Collection<OWLClass> getDescendantClasses(OWLClass aClass)
                                              throws ProtegeReasonerException

  Gets the inferred descendant classes of the specified class. The inferred descendant classes is equivalent to the transitive closure of the inferred subclasses.

  Parameters:
    `aClass` - The class whose descendent classes are to be retrieved.
  Returns:
    A `Collection` containing the inferred descendent classes.
  Throws:
    `ProtegeReasonerException`

### getEquivalentClasses

    Collection<OWLClass> getEquivalentClasses(OWLClass aClass)
                                              throws ProtegeReasonerException

  Gets the equivalent classes of the specified class.

  Parameters:
    `aClass` - The class whose equivalent classes are to be retrieved.
  Returns:
    A `Collection` containing the inferred equivalent classes of the specified class.
  Throws:
    `ProtegeReasonerException`

### getSuperProperties

    Collection<OWLProperty> getSuperProperties(OWLProperty property)
                                               throws ProtegeReasonerException

  Throws:
    `ProtegeReasonerException`

### getAncestorProperties

    Collection<OWLProperty> getAncestorProperties(OWLProperty property)
                                                  throws ProtegeReasonerException

  Throws:
    `ProtegeReasonerException`

### getSubProperties

    Collection<OWLProperty> getSubProperties(OWLProperty property)
                                             throws ProtegeReasonerException

  Throws:
    `ProtegeReasonerException`

### getDescendantProperties

    Collection<OWLProperty> getDescendantProperties(OWLProperty property)
                                                    throws ProtegeReasonerException

  Throws:
    `ProtegeReasonerException`

### getIndividualsBelongingToClass

    Collection<OWLIndividual> getIndividualsBelongingToClass(OWLClass aClass)
                                                             throws ProtegeReasonerException

  Gets the individuals that are inferred to be members of the specified class.

  Parameters:
    `aClass` - The class whose members are to be retrieved.
  Returns:
    A `Collection` containing the `OWLIndividuals` that are members of the specified class.
  Throws:
    `ProtegeReasonerException`

### getIndividualTypes

    Collection<OWLClass> getIndividualTypes(OWLIndividual individual)
                                            throws ProtegeReasonerException

  Get the inferred types (direct and indirect) for the specified individual.

  Parameters:
    `individual` - The individual whose inferred types are to be retrieved.
  Returns:
    A `Collection` of `OWLClasses` that represent the inferred types for the specified individual.
  Throws:
    `ProtegeReasonerException`

### getIndividualDirectTypes

    Collection<OWLClass> getIndividualDirectTypes(OWLIndividual individual)
                                                  throws ProtegeReasonerException

  Get the direct inferred types for the specified individual.

  Parameters:
    `individual` - The individual whose inferred direct types are to be retrieved.
  Returns:
    A `Collection` of `OWLClasses` that represent the inferred direct types for the specified individual.
  Throws:
    `ProtegeReasonerException`

### getRelatedIndividuals

    Collection<OWLIndividual> getRelatedIndividuals(OWLIndividual subject,
                                                    OWLObjectProperty objectProperty)
                                                    throws ProtegeReasonerException

  Get the individuals that are related to the `subject` individual through the object property `objectProperty`.

  Parameters:
    `subject` - - An `OWLIndividual`
    `objectProperty` - - A `OWLObjectProperty`
  Returns:
    A `Collection` of `OWLIndividuals` that are related to the `subject` individual through `objectProperty`
  Throws:
    `ProtegeReasonerException`

### getRelatedValues

    Collection getRelatedValues(OWLIndividual subject,
                                OWLDatatypeProperty datatypeProperty)
                                throws ProtegeReasonerException

  Get the values that are related to the `subject` individual through the datatype property `datatypeProperty`.

  Parameters:
    `subject` - - An `OWLIndividual`
    `objectProperty` - - A `OWLDatatypeProperty`
  Returns:
    A `Collection` of values that are related to the `subject` individual through `datatypeProperty`
  Throws:
    `ProtegeReasonerException`

### forceReasonerReSynchronization

    void forceReasonerReSynchronization()

  Depending on the implementation of the ProtegeGenericReasoner, some kind of caching may be used. This method will force the ProtegeOWLReasoner to synchronize the contents of the reasoner prior to the next query. (Note that this will not cause the reasoner to be resynchronized immediately - synchronisation will take place the next time the reasoner is queried).

### setAutoSynchronizationEnabled

    void setAutoSynchronizationEnabled(boolean b)

  Depending on the implementation of the ProtegeOWLReasoner, the DIG reasoner may automatically be sunchronized with changes in the Protege-OWL knowledgebase. This method will enable/disable this autosynchronization (if it is used). Note that if reasoner synchronisation is disabled, and then it is subsequently necessary to resynchronise the reasoner, the `forceReasonerReSynchronization` method should be used.

  Parameters:
    `b` - `true` to enable autosync, or `false` to disable autosync.

### isAutoSynchronizationEnabled

    boolean isAutoSynchronizationEnabled()

### setReasonerTaskListener

    void setReasonerTaskListener(ReasonerTaskListener reasonerTaskListener)

  Set the listener which will be informed of the progress of the reasoning task. May be `null` if the progress of the task does not need to be monitored.

  Parameters:
    `reasonerTaskListener` -

### getReasonerTaskListener

    ReasonerTaskListener getReasonerTaskListener()

Overview | Package | Class | Tree | Deprecated | Index | Help
| Protégé-OWL 3.4 rc2
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug report or feature request
Copyright (c) 1998-2009 Stanford University.