org.semanticweb.elk.reasoner.stages

Class AbstractReasonerState

java.lang.Object

org.semanticweb.elk.util.concurrent.computation.SimpleInterrupter

org.semanticweb.elk.reasoner.stages.AbstractReasonerState

All Implemented Interfaces:

Interrupter

Direct Known Subclasses:

Reasoner

public abstract class AbstractReasonerState
extends SimpleInterrupter

The execution state of the reasoner containing information about which reasoning stages have been completed and holding the results of these reasoning stages, such as the consistency status of the ontology, class, or instance taxonomy.

Author:

"Yevgeny Kazakov"

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractReasonerState()
protected	AbstractReasonerState(AxiomLoader axiomLoader)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	complete(ReasonerStage stage)
boolean	doneConsistencyCheck()
boolean	doneInstanceTaxonomy()
boolean	doneTaxonomy()
void	forceLoading() Forces loading of all axioms from the registered AxiomLoaders.
Set<ElkClass>	getAllClasses()
Set<ElkNamedIndividual>	getAllNamedIndividuals()
AxiomLoader	getAxiomLoader()
Map<IndexedClassExpression,Context>	getContextMap()
Collection<IndexedClassExpression>	getIndexedClassExpressions()
InstanceTaxonomy<ElkClass,ElkNamedIndividual>	getInstanceTaxonomy() Compute the inferred taxonomy of the named classes with instances if this has not been done yet.
InstanceTaxonomy<ElkClass,ElkNamedIndividual>	getInstanceTaxonomyQuietly() Compute the inferred taxonomy of the named classes with instances if this has not been done yet.
protected ModifiableOntologyIndex	getModifiableOntologyIndex()
protected abstract int	getNumberOfWorkers()
protected OntologyIndex	getOntologyIndex() Compute the index representation of the given ontology if it has not been done yet.
protected abstract ComputationExecutor	getProcessExecutor()
protected abstract ProgressMonitor	getProgressMonitor()
Map<IndexedPropertyChain,SaturatedPropertyChain>	getPropertySaturationMap()
protected abstract ReasonerStageExecutor	getStageExecutor()
Taxonomy<ElkClass>	getTaxonomy() Compute the inferred taxonomy of the named classes for the given ontology if it has not been done yet.
Taxonomy<ElkClass>	getTaxonomyQuietly() Compute the inferred taxonomy of the named classes for the given ontology if it has not been done yet.
void	initClassTaxonomy()
void	initInstanceTaxonomy()
void	interrupt() interrupts running reasoning stages
boolean	isAllowIncrementalMode()
boolean	isInconsistent() Check consistency of the current ontology, if this has not been done yet.
boolean	isIncrementalMode()
void	registerAxiomLoader(AxiomLoader newAxiomLoader)
void	resetAxiomLoading() Reset the axiom loading stage and all subsequent stages
void	resetPropertySaturation() Reset the property saturation stage and all subsequent stages
void	setAllowIncrementalMode(boolean allow)
protected boolean	setAllowIncrementalTaxonomy(boolean flag)
void	setInterrupt(boolean flag)
protected boolean	useIncrementalTaxonomy()

Methods inherited from class org.semanticweb.elk.util.concurrent.computation.SimpleInterrupter

isInterrupted

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractReasonerState

protected AbstractReasonerState()

AbstractReasonerState

protected AbstractReasonerState(AxiomLoader axiomLoader)

Method Detail

complete

protected void complete(ReasonerStage stage)
                 throws ElkException

Throws:

ElkException

setAllowIncrementalMode

public void setAllowIncrementalMode(boolean allow)

isAllowIncrementalMode

public boolean isAllowIncrementalMode()

isIncrementalMode

public boolean isIncrementalMode()

resetAxiomLoading

public void resetAxiomLoading()

Reset the axiom loading stage and all subsequent stages

resetPropertySaturation

public void resetPropertySaturation()

Reset the property saturation stage and all subsequent stages

registerAxiomLoader

public void registerAxiomLoader(AxiomLoader newAxiomLoader)

getAxiomLoader

public AxiomLoader getAxiomLoader()

Returns:

the AxiomLoader currently registered for loading of axioms or null if no loader is registered

forceLoading

public void forceLoading()
                  throws ElkException

Forces loading of all axioms from the registered AxiomLoaders. Typically, loading lazily when reasoning tasks are requested.

Throws:

ElkException - if the reasoning process cannot be completed successfully

getNumberOfWorkers

protected abstract int getNumberOfWorkers()

Returns:

the maximal number of workers that can be used for running concurrent reasoning tasks

getStageExecutor

protected abstract ReasonerStageExecutor getStageExecutor()

Returns:

the ReasonerStageExecutor that is used for executing the stages of the reasoner.

getProcessExecutor

protected abstract ComputationExecutor getProcessExecutor()

Returns:

the ComputationExecutor that is used for execution of reasoning processes

getProgressMonitor

protected abstract ProgressMonitor getProgressMonitor()

Returns:

the ProgressMonitor that is used for reporting progress on all potentially long-running operations.

getModifiableOntologyIndex

protected ModifiableOntologyIndex getModifiableOntologyIndex()

interrupt

public void interrupt()

interrupts running reasoning stages

isInconsistent

public boolean isInconsistent()
                       throws ElkException

Check consistency of the current ontology, if this has not been done yet.

Returns:

true if the ontology is inconsistent, that is, unsatisfiable.

Throws:

ElkException - if the reasoning process cannot be completed successfully

getTaxonomy

public Taxonomy<ElkClass> getTaxonomy()
                               throws ElkInconsistentOntologyException,
                                      ElkException

Compute the inferred taxonomy of the named classes for the given ontology if it has not been done yet.

Returns:

the class taxonomy implied by the current ontology

Throws:

ElkInconsistentOntologyException - if the ontology is inconsistent

ElkException - if the reasoning process cannot be completed successfully

getTaxonomyQuietly

public Taxonomy<ElkClass> getTaxonomyQuietly()
                                      throws ElkException

Compute the inferred taxonomy of the named classes for the given ontology if it has not been done yet.

Returns:

the class taxonomy implied by the current ontology

Throws:

ElkException - if the reasoning process cannot be completed successfully

getInstanceTaxonomy

public InstanceTaxonomy<ElkClass,ElkNamedIndividual> getInstanceTaxonomy()
                                                                  throws ElkException

Compute the inferred taxonomy of the named classes with instances if this has not been done yet.

Returns:

the instance taxonomy implied by the current ontology

Throws:

ElkInconsistentOntologyException - if the ontology is inconsistent

ElkException - if the reasoning process cannot be completed successfully

getInstanceTaxonomyQuietly

public InstanceTaxonomy<ElkClass,ElkNamedIndividual> getInstanceTaxonomyQuietly()
                                                                         throws ElkException

Compute the inferred taxonomy of the named classes with instances if this has not been done yet.

Returns:

the instance taxonomy implied by the current ontology

Throws:

ElkException - if the reasoning process cannot be completed successfully

getAllClasses

public Set<ElkClass> getAllClasses()

Returns:

all ElkClasses occurring in the ontology

getAllNamedIndividuals

public Set<ElkNamedIndividual> getAllNamedIndividuals()

Returns:

all ElkNamedIndividuals occurring in the ontology

getContextMap

public Map<IndexedClassExpression,Context> getContextMap()

getPropertySaturationMap

public Map<IndexedPropertyChain,SaturatedPropertyChain> getPropertySaturationMap()

doneConsistencyCheck

public boolean doneConsistencyCheck()

Returns:

true if the ontology has been checked for consistency.

doneTaxonomy

public boolean doneTaxonomy()

Returns:

true if the class taxonomy has been computed

doneInstanceTaxonomy

public boolean doneInstanceTaxonomy()

Returns:

true if the instance taxonomy has been computed

setInterrupt

public void setInterrupt(boolean flag)

Specified by:

setInterrupt in interface Interrupter

Overrides:

setInterrupt in class SimpleInterrupter

getOntologyIndex

protected OntologyIndex getOntologyIndex()
                                  throws ElkException

Compute the index representation of the given ontology if it has not been done yet.

Returns:

the index representation of the given ontology

Throws:

ElkException - if the reasoning process cannot be completed successfully

setAllowIncrementalTaxonomy

protected boolean setAllowIncrementalTaxonomy(boolean flag)

useIncrementalTaxonomy

protected boolean useIncrementalTaxonomy()

initClassTaxonomy

public void initClassTaxonomy()

initInstanceTaxonomy

public void initInstanceTaxonomy()

getIndexedClassExpressions

public Collection<IndexedClassExpression> getIndexedClassExpressions()