org.semanticweb.HermiT.existentials
Class IndividualReuseStrategy

java.lang.Object
  extended by org.semanticweb.HermiT.existentials.StrategyBase
      extended by org.semanticweb.HermiT.existentials.IndividualReuseStrategy
All Implemented Interfaces:
java.io.Serializable, ExpansionStrategy

public class IndividualReuseStrategy
extends StrategyBase
implements java.io.Serializable

See Also:
Serialized Form

Nested Class Summary
protected  class IndividualReuseStrategy.IndividualReuseBranchingPoint
           
protected static class IndividualReuseStrategy.NodeBranchingPointPair
           
 
Nested classes/interfaces inherited from class org.semanticweb.HermiT.existentials.StrategyBase
StrategyBase.Expander
 
Field Summary
protected  java.lang.Object[] auxiliaryBuffer
           
protected  java.util.Set<LiteralConcept> dontReuseConceptsEver
           
protected  java.util.Set<LiteralConcept> dontReuseConceptsThisRun
           
protected  java.util.Set<LiteralConcept> doReuseConceptsAlways
           
protected  StrategyBase.Expander expander
           
protected  int[] indicesByBranchingPoint
           
protected  boolean isDeterministic
           
protected  TupleTable reuseBacktrackingTable
           
protected  java.util.Map<LiteralConcept,IndividualReuseStrategy.NodeBranchingPointPair> reusedNodes
           
private static long serialVersionUID
           
 
Fields inherited from class org.semanticweb.HermiT.existentials.StrategyBase
blockingStrategy, curExistentials, descriptionGraphManager, existentialExpansionManager, extensionManager, tableau
 
Constructor Summary
IndividualReuseStrategy(BlockingStrategy strategy, boolean isDeterministic)
           
 
Method Summary
 void backtrack()
           
 void branchingPointPushed()
           
 void clear()
           
 boolean expandExistentials()
          The main workhorse of the interface: pick some existential in the current tableau and expand it.
protected  boolean expandWithModelReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node node)
           
 LiteralConcept getConceptForNode(Node node)
           
 java.util.Set<LiteralConcept> getDontReuseConceptsEver()
           
 void initialize(Tableau tableau)
           
 boolean isDeterministic()
           
 void modelFound()
           
protected  boolean tryParentReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node node)
           
 
Methods inherited from class org.semanticweb.HermiT.existentials.StrategyBase
assertionAdded, assertionAdded, assertionRemoved, assertionRemoved, expandExistentials, nodeDestroyed, nodeStatusChanged
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

serialVersionUID

private static final long serialVersionUID
See Also:
Constant Field Values

expander

protected final StrategyBase.Expander expander

reusedNodes

protected final java.util.Map<LiteralConcept,IndividualReuseStrategy.NodeBranchingPointPair> reusedNodes

doReuseConceptsAlways

protected final java.util.Set<LiteralConcept> doReuseConceptsAlways

dontReuseConceptsThisRun

protected final java.util.Set<LiteralConcept> dontReuseConceptsThisRun

dontReuseConceptsEver

protected final java.util.Set<LiteralConcept> dontReuseConceptsEver

reuseBacktrackingTable

protected final TupleTable reuseBacktrackingTable

auxiliaryBuffer

protected final java.lang.Object[] auxiliaryBuffer

indicesByBranchingPoint

protected int[] indicesByBranchingPoint

isDeterministic

protected final boolean isDeterministic
Constructor Detail

IndividualReuseStrategy

public IndividualReuseStrategy(BlockingStrategy strategy,
                               boolean isDeterministic)
Method Detail

initialize

public void initialize(Tableau tableau)
Specified by:
initialize in interface ExpansionStrategy
Overrides:
initialize in class StrategyBase

clear

public void clear()
Specified by:
clear in interface ExpansionStrategy
Overrides:
clear in class StrategyBase

expandExistentials

public boolean expandExistentials()
Description copied from interface: ExpansionStrategy
The main workhorse of the interface: pick some existential in the current tableau and expand it.

Specified by:
expandExistentials in interface ExpansionStrategy
Returns:
true if at least one of the extensions changed as the result of the expansion

tryParentReuse

protected boolean tryParentReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept,
                                 Node node)

expandWithModelReuse

protected boolean expandWithModelReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept,
                                       Node node)

branchingPointPushed

public void branchingPointPushed()
Specified by:
branchingPointPushed in interface ExpansionStrategy
Overrides:
branchingPointPushed in class StrategyBase

backtrack

public void backtrack()
Specified by:
backtrack in interface ExpansionStrategy
Overrides:
backtrack in class StrategyBase

modelFound

public void modelFound()
Specified by:
modelFound in interface ExpansionStrategy
Overrides:
modelFound in class StrategyBase

isDeterministic

public boolean isDeterministic()
Specified by:
isDeterministic in interface ExpansionStrategy
Overrides:
isDeterministic in class StrategyBase

getConceptForNode

public LiteralConcept getConceptForNode(Node node)

getDontReuseConceptsEver

public java.util.Set<LiteralConcept> getDontReuseConceptsEver()