Uses of Class
org.semanticweb.HermiT.tableau.Node

Packages that use Node
org.semanticweb.HermiT.blocking   
org.semanticweb.HermiT.debugger   
org.semanticweb.HermiT.debugger.commands   
org.semanticweb.HermiT.existentials   
org.semanticweb.HermiT.hierarchy   
org.semanticweb.HermiT.monitor   
org.semanticweb.HermiT.tableau   
 

Uses of Node in org.semanticweb.HermiT.blocking
 

Fields in org.semanticweb.HermiT.blocking declared as Node
protected  Node AnywhereBlocking.m_firstChangedNode
           
protected  Node BlockingCache.CacheEntry.m_node
           
 

Methods in org.semanticweb.HermiT.blocking that return Node
 Node BlockingCache.getBlocker(Node node)
           
 

Methods in org.semanticweb.HermiT.blocking with parameters of type Node
 BlockingCache.CacheEntry BlockingCache.addNode(Node node)
           
 boolean BlockingSignatureCache.addNode(Node node)
           
 void BlockingStrategy.assertionAdded(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void AnywhereBlocking.assertionAdded(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void AncestorBlocking.assertionAdded(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void BlockingStrategy.assertionAdded(Concept concept, Node node)
           
 void AnywhereBlocking.assertionAdded(Concept concept, Node node)
           
 void AncestorBlocking.assertionAdded(Concept concept, Node node)
           
 void BlockingStrategy.assertionRemoved(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void AnywhereBlocking.assertionRemoved(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void AncestorBlocking.assertionRemoved(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void BlockingStrategy.assertionRemoved(Concept concept, Node node)
           
 void AnywhereBlocking.assertionRemoved(Concept concept, Node node)
           
 void AncestorBlocking.assertionRemoved(Concept concept, Node node)
           
 int SingleDirectBlockingChecker.blockingHashCode(Node node)
           
 int PairwiseDirectBlockingCheckerWithReflexivity.blockingHashCode(Node node)
           
 int PairWiseDirectBlockingChecker.blockingHashCode(Node node)
           
 int DirectBlockingChecker.blockingHashCode(Node node)
           
 boolean SingleDirectBlockingChecker.SingleBlockingSignature.blocksNode(Node node)
           
 boolean PairwiseDirectBlockingCheckerWithReflexivity.PairWiseBlockingSignatureWithReflexivity.blocksNode(Node node)
           
 boolean PairWiseDirectBlockingChecker.PairWiseBlockingSignature.blocksNode(Node node)
           
abstract  boolean BlockingSignature.blocksNode(Node node)
           
 boolean SingleDirectBlockingChecker.canBeBlocked(Node node)
           
 boolean PairwiseDirectBlockingCheckerWithReflexivity.canBeBlocked(Node node)
           
 boolean PairWiseDirectBlockingChecker.canBeBlocked(Node node)
           
 boolean DirectBlockingChecker.canBeBlocked(Node node)
           
 boolean SingleDirectBlockingChecker.canBeBlocker(Node node)
           
 boolean PairwiseDirectBlockingCheckerWithReflexivity.canBeBlocker(Node node)
           
 boolean PairWiseDirectBlockingChecker.canBeBlocker(Node node)
           
 boolean DirectBlockingChecker.canBeBlocker(Node node)
           
protected  void AncestorBlocking.checkParentBlocking(Node node)
           
 boolean BlockingSignatureCache.containsSignature(Node node)
           
 Node BlockingCache.getBlocker(Node node)
           
 BlockingSignature SingleDirectBlockingChecker.getBlockingSignatureFor(Node node)
           
 BlockingSignature PairwiseDirectBlockingCheckerWithReflexivity.getBlockingSignatureFor(Node node)
           
 BlockingSignature PairWiseDirectBlockingChecker.getBlockingSignatureFor(Node node)
           
 BlockingSignature DirectBlockingChecker.getBlockingSignatureFor(Node node)
           
 void BlockingCache.CacheEntry.initialize(Node node, int hashCode, BlockingCache.CacheEntry nextEntry)
           
 boolean SingleDirectBlockingChecker.isBlockedBy(Node blocker, Node blocked)
           
 boolean PairwiseDirectBlockingCheckerWithReflexivity.isBlockedBy(Node blocker, Node blocked)
           
 boolean PairWiseDirectBlockingChecker.isBlockedBy(Node blocker, Node blocked)
           
 boolean DirectBlockingChecker.isBlockedBy(Node blocker, Node blocked)
           
 void BlockingStrategy.nodeDestroyed(Node node)
           
 void AnywhereBlocking.nodeDestroyed(Node node)
           
 void AncestorBlocking.nodeDestroyed(Node node)
           
 void BlockingStrategy.nodeStatusChanged(Node node)
           
 void AnywhereBlocking.nodeStatusChanged(Node node)
           
 void AncestorBlocking.nodeStatusChanged(Node node)
           
protected  void AnywhereBlocking.updateNodeChange(Node node)
           
 

Constructors in org.semanticweb.HermiT.blocking with parameters of type Node
PairWiseDirectBlockingChecker.PairWiseBlockingSignature(Node node)
           
PairwiseDirectBlockingCheckerWithReflexivity.PairWiseBlockingSignatureWithReflexivity(Node node)
           
SingleDirectBlockingChecker.SingleBlockingSignature(Node node)
           
 

Uses of Node in org.semanticweb.HermiT.debugger
 

Fields in org.semanticweb.HermiT.debugger declared as Node
 Node Debugger.NodeCreationInfo.m_createdByNode
           
protected  Node Debugger.m_lastExistentialNode
           
 Node Debugger.NodeCreationInfo.m_node
           
 

Fields in org.semanticweb.HermiT.debugger with type parameters of type Node
 java.util.List<Node> Debugger.NodeCreationInfo.m_children
           
protected  java.util.Map<Node,Debugger.NodeCreationInfo> Debugger.m_nodeCreationInfos
           
 

Methods in org.semanticweb.HermiT.debugger that return Node
 Node DerivationHistory.Atom.getArgument(int index)
           
 Node DerivationHistory.Disjunction.getArgument(int disjunctIndex, int argumentIndex)
           
 

Methods in org.semanticweb.HermiT.debugger with parameters of type Node
 int Debugger.NodeComparator.compare(Node o1, Node o2)
           
 void DerivationHistory.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void Debugger.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void DerivationHistory.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
 void Debugger.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
protected static java.lang.String Debugger.formatBlockingStatus(Node node)
           
 Debugger.NodeCreationInfo Debugger.getNodeCreationInfo(Node node)
           
 void DerivationHistory.mergeFactFinished(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void DerivationHistory.mergeFactStarted(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void DerivationHistory.mergeFinished(Node nodeFrom, Node nodeInto)
           
 void DerivationHistory.mergeStarted(Node nodeFrom, Node nodeInto)
           
 void Debugger.mergeStarted(Node mergeFrom, Node mergeInto)
           
 void Debugger.nodeCreated(Node node)
           
 void Debugger.nodeDestroyed(Node node)
           
 void Debugger.printConceptLabel(Node node, java.io.PrintWriter writer)
           
 void Debugger.printEdges(Node node, java.io.PrintWriter writer)
           
 void Debugger.printNodeData(Node node, java.io.PrintWriter writer)
           
 

Method parameters in org.semanticweb.HermiT.debugger with type arguments of type Node
protected  void Debugger.printEdgeMap(java.util.Map<Node,java.util.Set<AtomicRole>> map, java.io.PrintWriter writer)
           
 

Constructors in org.semanticweb.HermiT.debugger with parameters of type Node
Debugger.NodeCreationInfo(Node node, Node createdByNode, ExistentialConcept createdByExistential)
           
 

Uses of Node in org.semanticweb.HermiT.debugger.commands
 

Fields in org.semanticweb.HermiT.debugger.commands declared as Node
protected  Node SubtreeViewer.SubtreeTreeModel.m_root
           
 

Fields in org.semanticweb.HermiT.debugger.commands with type parameters of type Node
 java.util.List<Node> OriginStatsCommand.OriginInfo.m_nodes
           
 

Methods in org.semanticweb.HermiT.debugger.commands that return Node
 Node SubtreeViewer.SubtreeTreeModel.getChild(java.lang.Object parent, int index)
           
 

Methods in org.semanticweb.HermiT.debugger.commands with parameters of type Node
 void SubtreeViewer.findNode(Node node)
           
protected static java.lang.String AbstractCommand.formatBlockingStatus(Node node)
           
protected  void ShowExistsCommand.printStartExistential(Node node, java.io.PrintWriter writer)
           
 void SubtreeViewer.showNodeLabels(Node node)
           
 

Constructors in org.semanticweb.HermiT.debugger.commands with parameters of type Node
SubtreeViewer.SubtreeTreeModel(Debugger debugger, Node root)
           
SubtreeViewer(Debugger debugger, Node rootNode)
           
 

Uses of Node in org.semanticweb.HermiT.existentials
 

Fields in org.semanticweb.HermiT.existentials declared as Node
protected  Node IndividualReuseStrategy.IndividualReuseBranchingPoint.node
           
protected  Node IndividualReuseStrategy.NodeBranchingPointPair.node
           
 

Methods in org.semanticweb.HermiT.existentials with parameters of type Node
 void StrategyBase.assertionAdded(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void ExpansionStrategy.assertionAdded(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void StrategyBase.assertionAdded(Concept concept, Node node)
           
 void ExpansionStrategy.assertionAdded(Concept concept, Node node)
           
 void StrategyBase.assertionRemoved(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void ExpansionStrategy.assertionRemoved(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void StrategyBase.assertionRemoved(Concept concept, Node node)
           
 void ExpansionStrategy.assertionRemoved(Concept concept, Node node)
           
 boolean StrategyBase.Expander.expand(AtLeastAbstractRoleConcept c, Node n)
          called once for each unsatisfied existential in the tableau
protected  boolean IndividualReuseStrategy.expandWithModelReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node node)
           
 LiteralConcept IndividualReuseStrategy.getConceptForNode(Node node)
           
 void StrategyBase.nodeDestroyed(Node node)
           
 void ExpansionStrategy.nodeDestroyed(Node node)
           
 void StrategyBase.nodeStatusChanged(Node node)
           
 void ExpansionStrategy.nodeStatusChanged(Node node)
           
protected  boolean IndividualReuseStrategy.tryParentReuse(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node node)
           
 

Constructors in org.semanticweb.HermiT.existentials with parameters of type Node
IndividualReuseStrategy.IndividualReuseBranchingPoint(Tableau tableau, AtLeastAbstractRoleConcept existential, Node node, boolean wasParentReuse)
           
IndividualReuseStrategy.NodeBranchingPointPair(Node node, int branchingPoint)
           
 

Uses of Node in org.semanticweb.HermiT.hierarchy
 

Methods in org.semanticweb.HermiT.hierarchy with parameters of type Node
 void TableauSubsumptionChecker.AtomicConceptInfo.updatePossibleSubsumers(Tableau tableau, Node node)
           
 

Uses of Node in org.semanticweb.HermiT.monitor
 

Methods in org.semanticweb.HermiT.monitor with parameters of type Node
 void TableauMonitorForwarder.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorFork.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorAdapter.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitor.existentialExpansionFinished(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorForwarder.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorFork.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorAdapter.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitor.existentialExpansionStarted(ExistentialConcept existentialConcept, Node forNode)
           
 void Timer.existentialSatisfied(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorForwarder.existentialSatisfied(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorFork.existentialSatisfied(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorAdapter.existentialSatisfied(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitor.existentialSatisfied(ExistentialConcept existentialConcept, Node forNode)
           
 void TableauMonitorForwarder.mergeFactFinished(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorFork.mergeFactFinished(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorAdapter.mergeFactFinished(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitor.mergeFactFinished(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorForwarder.mergeFactStarted(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorFork.mergeFactStarted(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorAdapter.mergeFactStarted(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitor.mergeFactStarted(Node mergeFrom, Node mergeInto, java.lang.Object[] sourceTuple, java.lang.Object[] targetTuple)
           
 void TableauMonitorForwarder.mergeFinished(Node mergeFrom, Node mergeInto)
           
 void TableauMonitorFork.mergeFinished(Node mergeFrom, Node mergeInto)
           
 void TableauMonitorAdapter.mergeFinished(Node mergeFrom, Node mergeInto)
           
 void TableauMonitor.mergeFinished(Node mergeFrom, Node mergeInto)
           
 void TableauMonitorForwarder.mergeStarted(Node mergeFrom, Node mergrInto)
           
 void TableauMonitorFork.mergeStarted(Node mergeFrom, Node mergeInto)
           
 void TableauMonitorAdapter.mergeStarted(Node mergeFrom, Node mergeInto)
           
 void TableauMonitor.mergeStarted(Node mergeFrom, Node mergeInto)
           
 void TableauMonitorForwarder.nodeCreated(Node node)
           
 void TableauMonitorFork.nodeCreated(Node node)
           
 void TableauMonitorAdapter.nodeCreated(Node node)
           
 void TableauMonitor.nodeCreated(Node node)
           
 void TableauMonitorForwarder.nodeDestroyed(Node node)
           
 void TableauMonitorFork.nodeDestroyed(Node node)
           
 void TableauMonitorAdapter.nodeDestroyed(Node node)
           
 void TableauMonitor.nodeDestroyed(Node node)
           
 void TableauMonitorForwarder.nodePruned(Node node)
           
 void TableauMonitorFork.nodePruned(Node node)
           
 void TableauMonitorAdapter.nodePruned(Node node)
           
 void TableauMonitor.nodePruned(Node node)
           
 void TableauMonitorForwarder.nominalIntorductionFinished(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitorFork.nominalIntorductionFinished(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitorAdapter.nominalIntorductionFinished(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitor.nominalIntorductionFinished(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitorForwarder.nominalIntorductionStarted(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitorFork.nominalIntorductionStarted(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitorAdapter.nominalIntorductionStarted(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 void TableauMonitor.nominalIntorductionStarted(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)
           
 

Uses of Node in org.semanticweb.HermiT.tableau
 

Fields in org.semanticweb.HermiT.tableau declared as Node
static Node Node.CACHE_BLOCKER
           
protected  Node Tableau.m_arbitraryOriginalNode
           
protected  Node[] GroundDisjunction.m_arguments
           
protected  Node Node.m_blocker
           
protected  Node Tableau.m_checkedNode
           
protected  Node Tableau.m_firstFreeNode
           
protected  Node Tableau.m_firstTableauNode
           
protected  Node Tableau.m_lastMergedOrPrunedNode
           
protected  Node BranchingPoint.m_lastMergedOrPrunedNode
           
protected  Node Tableau.m_lastTableauNode
           
protected  Node BranchingPoint.m_lastTableauNode
           
protected  Node Node.m_mergedInto
           
protected  Node Node.m_nextTableauNode
           
protected  Node Node.m_parent
           
protected  Node Node.m_previousMergedOrPrunedNode
           
protected  Node Node.m_previousTableauNode
           
protected  Node NominalIntroductionManager.NominalIntroductionBranchingPoint.m_rootNode
           
protected  Node NominalIntroductionManager.NominalIntroductionBranchingPoint.m_treeNode
           
 

Fields in org.semanticweb.HermiT.tableau with type parameters of type Node
private  java.util.List<Node> ExistentialExpansionManager.m_auxiliaryNodes1
           
private  java.util.List<Node> ExistentialExpansionManager.m_auxiliaryNodes2
           
protected  java.util.List<Node> DescriptionGraphManager.m_newNodes
           
 

Methods in org.semanticweb.HermiT.tableau that return Node
 Node Tableau.createNewConcreteNode(DependencySet dependencySet, Node parent)
           
 Node Tableau.createNewGraphNode(Node parent, DependencySet dependencySet)
           
 Node Tableau.createNewNodeRaw(DependencySet dependencySet, Node parent, NodeType nodeType, int treeDepth)
           
 Node Tableau.createNewOriginalNode(DependencySet dependencySet, int treeDepth)
           
 Node Tableau.createNewRootNode(DependencySet dependencySet, int treeDepth)
           
 Node Tableau.createNewTreeNode(DependencySet dependencySet, Node parent)
           
 Node GroundDisjunction.getArgument(int disjunctIndex, int argumentIndex)
           
 Node Node.getBlocker()
           
 Node Node.getCanonicalNode()
           
 Node Tableau.getCheckedNode()
           
 Node Tableau.getFirstTableauNode()
           
 Node Tableau.getLastTableauNode()
           
 Node Node.getMergedInto()
           
 Node Node.getNextTableauNode()
           
 Node Tableau.getNode(int nodeID)
           
private  Node Tableau.getNodeForIndividual(java.util.Map<Individual,Node> individualsToNodes, Individual individual)
           
 Node Node.getParent()
           
 Node Node.getPreviousTableauNode()
           
protected  Node NominalIntroductionManager.getRootNodeFor(DependencySet dependencySet, Node rootNode, AtMostAbstractRoleGuard atMostRoleGuard, int number)
           
 

Methods in org.semanticweb.HermiT.tableau that return types with arguments of type Node
protected  java.util.Map<Node,CanonicalDataRange> DatatypeManager.buildCanonicalRanges(java.util.Map<Node,java.util.Set<DataRange>> nodeToDRs)
          Given a map from nodes to a set of data ranges, construct a map from nodes to data ranges such that each constructed data range captures all restrictions of the data ranges in the set for the node in the given map.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  java.util.Map<Node,java.util.Set<DataRange>> DatatypeManager.fetchRelevantAssertions(Node initialNode)
          Given a node that has a data range assertion in the extension table, look up its predecessor node in the tableau (unique for data range nodes) and collect all successors of the fond predecessor that have data range assertions.
 

Methods in org.semanticweb.HermiT.tableau with parameters of type Node
 boolean ExtensionManager.addAssertion(DLPredicate dlPredicate, Node[] nodes, DependencySet dependencySet)
           
 boolean ExtensionManager.addAssertion(DLPredicate dlPredicate, Node node, DependencySet dependencySet)
           
 boolean ExtensionManager.addAssertion(DLPredicate dlPredicate, Node node0, Node node1, DependencySet dependencySet)
           
 void NominalIntroductionManager.addAtomicRoleAssertion(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 boolean ExtensionManager.addConceptAssertion(Concept concept, Node node, DependencySet dependencySet)
           
 void NominalIntroductionManager.addNonnegativeConceptAssertion(Concept concept, Node node)
           
 boolean ExtensionManager.addRoleAssertion(Role abstractRole, Node nodeFrom, Node nodeTo, DependencySet dependencySet)
           
protected  void NominalIntroductionManager.addTarget(Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMost)
           
 boolean ExtensionManager.containsAssertion(DLPredicate dlPredicate, Node node)
           
 boolean ExtensionManager.containsAssertion(DLPredicate dlPredicate, Node[] nodes)
           
 boolean ExtensionManager.containsAssertion(DLPredicate dlPredicate, Node node0, Node node1)
           
 boolean ExtensionManager.containsConceptAssertion(Concept concept, Node node)
           
 boolean ExtensionManager.containsRoleAssertion(Role abstractRole, Node nodeFrom, Node nodeTo)
           
private  boolean ExistentialExpansionManager.containsSubsetOfNUnequalNodes(Node forNode, java.util.List<Node> nodes, int startAt, java.util.List<Node> selectedNodes, int cardinality)
           
 Node Tableau.createNewConcreteNode(DependencySet dependencySet, Node parent)
           
 Node Tableau.createNewGraphNode(Node parent, DependencySet dependencySet)
           
 Node Tableau.createNewNodeRaw(DependencySet dependencySet, Node parent, NodeType nodeType, int treeDepth)
           
 Node Tableau.createNewTreeNode(DependencySet dependencySet, Node parent)
           
 void DescriptionGraphManager.destroyNode(Node node)
           
 void ExistentialExpansionManager.doNormalExpansion(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node forNode)
          Does a normal expansion of the tableau (ABox) for an at least concept.
 void ExistentialExpansionManager.expand(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node forNode)
          Expands an at least concept by first trying a functional expansion (if the cardinality is 1 or the role is functional) and a normal expansion otherwise.
 void ExistentialExpansionManager.expand(AtLeastConcreteRoleConcept c, Node n)
           
 void DescriptionGraphManager.expand(ExistsDescriptionGraph existsDescriptionGraph, Node forNode)
           
protected  java.util.Map<Node,java.util.Set<DataRange>> DatatypeManager.fetchRelevantAssertions(Node initialNode)
          Given a node that has a data range assertion in the extension table, look up its predecessor node in the tableau (unique for data range nodes) and collect all successors of the fond predecessor that have data range assertions.
 DependencySet ExtensionManager.getAssertionDependencySet(DLPredicate dlPredicate, Node node)
           
 DependencySet ExtensionManager.getAssertionDependencySet(DLPredicate dlPredicate, Node[] nodes)
           
 DependencySet ExtensionManager.getAssertionDependencySet(DLPredicate dlPredicate, Node node0, Node node1)
           
 DependencySet ExtensionManager.getConceptAssertionDependencySet(Concept concept, Node node)
           
 java.util.Set<AtomicRole> LabelManager.getEdgeLabel(Node nodeFrom, Node nodeTo)
           
private  boolean ExistentialExpansionManager.getFunctionalExpansionNode(Role abstractRole, Node forNode, java.lang.Object[] result)
           
 java.util.Set<Concept> LabelManager.getPositiveLabel(Node node)
           
 DependencySet ExtensionManager.getRoleAssertionDependencySet(Role abstractRole, Node nodeFrom, Node nodeTo)
           
protected  Node NominalIntroductionManager.getRootNodeFor(DependencySet dependencySet, Node rootNode, AtMostAbstractRoleGuard atMostRoleGuard, int number)
           
protected  void Node.initialize(int nodeID, Node parent, NodeType nodeType, int treeDepth)
           
 void DescriptionGraphManager.intializeNode(Node node)
           
 boolean Node.isAncestorOf(Node potendialDescendant)
           
 boolean Node.isParentOf(Node potentialChild)
           
 ExistentialExpansionManager.SatType ExistentialExpansionManager.isSatisfied(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node forNode)
           
 boolean ExistentialExpansionManager.isSatisfied(AtLeastConcreteRoleConcept atLeastConcreteRoleConcept, Node forNode)
           
 boolean DescriptionGraphManager.isSatisfied(ExistsDescriptionGraph existsDescriptionGraph, Node node)
           
 void ExistentialExpansionManager.markExistentialProcessed(ExistentialConcept existentialConcept, Node forNode)
           
 void DescriptionGraphManager.mergeGraphs(Node mergeFrom, Node mergeInto, UnionDependencySet binaryUnionDependencySet)
           
 void Tableau.mergeNode(Node node, Node mergeInto, DependencySet dependencySet)
           
 boolean MergingManager.mergeNodes(Node node0, Node node1, DependencySet dependencySet)
          Merges the two given nodes and adjusts the dependency set as required.
 void Tableau.pruneNode(Node node)
           
 void NominalIntroductionManager.removeAtomicRoleAssertion(AtomicRole atomicRole, Node nodeFrom, Node nodeTo)
           
 void Node.setBlocked(Node blocker, boolean directlyBlocked)
           
 boolean ExistentialExpansionManager.tryFunctionalExpansion(AtLeastAbstractRoleConcept atLeastAbstractConcept, Node forNode)
          Creates a new node in the tableau if at least concept that caused the expansion is for cardinality 1.
 

Method parameters in org.semanticweb.HermiT.tableau with type arguments of type Node
protected  java.util.Map<Node,CanonicalDataRange> DatatypeManager.buildCanonicalRanges(java.util.Map<Node,java.util.Set<DataRange>> nodeToDRs)
          Given a map from nodes to a set of data ranges, construct a map from nodes to data ranges such that each constructed data range captures all restrictions of the data ranges in the set for the node in the given map.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  java.util.Set<java.util.Map<CanonicalDataRange,Node>> DatatypeManager.buildPartitions(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Partition the set of nodes and their canonical data ranges together with their inequalities into mutally disjoint non-empty subsets P1, ..., Pn such that no Pi and Pj with i neq j have variables in common.
protected  boolean DatatypeManager.checkDatatypeAssertionFor(java.util.Map<Node,java.util.Set<DataRange>> nodeToDRs)
          Given a map with nodes and data range assertions for the nodes, check whether there is an assignment for all the data ranges that is consistent with the restrictions on the data ranges and the inequalities
private  boolean ExistentialExpansionManager.containsSubsetOfNUnequalNodes(Node forNode, java.util.List<Node> nodes, int startAt, java.util.List<Node> selectedNodes, int cardinality)
           
private  boolean ExistentialExpansionManager.containsSubsetOfNUnequalNodes(Node forNode, java.util.List<Node> nodes, int startAt, java.util.List<Node> selectedNodes, int cardinality)
           
protected  boolean DatatypeManager.fetchInequalities(java.util.Set<Node> nodes, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Given a set of nodes for which there are data range assertions in the tableau, collect all inequalities for the nodes.
protected  boolean DatatypeManager.fetchInequalities(java.util.Set<Node> nodes, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Given a set of nodes for which there are data range assertions in the tableau, collect all inequalities for the nodes.
protected  boolean DatatypeManager.fetchInequalities(java.util.Set<Node> nodes, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Given a set of nodes for which there are data range assertions in the tableau, collect all inequalities for the nodes.
protected  boolean DatatypeManager.fetchInequalities(java.util.Set<Node> nodes, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Given a set of nodes for which there are data range assertions in the tableau, collect all inequalities for the nodes.
protected  boolean DatatypeManager.fetchInequalities(java.util.Set<Node> nodes, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Given a set of nodes for which there are data range assertions in the tableau, collect all inequalities for the nodes.
private  Node Tableau.getNodeForIndividual(java.util.Map<Individual,Node> individualsToNodes, Individual individual)
           
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
protected  boolean DatatypeManager.hasAssignment(java.util.Map<CanonicalDataRange,Node> partition, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym, java.util.Map<Node,java.util.Set<DataRange>> originalNodeToDRs)
          Given a map from data ranges to nodes and inequalities between the nodes, check whether there is a suitable assignment of values for the nodes that complies with the given datatype restrictions and inequalities.
private  void Tableau.loadNegativeFact(Atom atom, java.util.Map<Individual,Node> individualsToNodes)
           
private  void Tableau.loadPositiveFact(Atom atom, java.util.Map<Individual,Node> individualsToNodes)
           
protected  void DatatypeManager.removeUnderRestrictedRanges(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Remove those nodes and data ranges that have more than enough values to cover the inequalities.
protected  void DatatypeManager.removeUnderRestrictedRanges(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Remove those nodes and data ranges that have more than enough values to cover the inequalities.
protected  void DatatypeManager.removeUnderRestrictedRanges(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Remove those nodes and data ranges that have more than enough values to cover the inequalities.
protected  void DatatypeManager.removeUnderRestrictedRanges(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Remove those nodes and data ranges that have more than enough values to cover the inequalities.
protected  void DatatypeManager.removeUnderRestrictedRanges(java.util.Map<Node,CanonicalDataRange> nodeToCanonicalDR, java.util.Map<Node,java.util.Set<Node>> inequalities, java.util.Map<Node,java.util.Set<Node>> inequalitiesSym)
          Remove those nodes and data ranges that have more than enough values to cover the inequalities.
 

Constructors in org.semanticweb.HermiT.tableau with parameters of type Node
GroundDisjunction(Tableau tableau, DLPredicate[] dlPredicates, int[] disjunctStart, Node[] arguments, DependencySet dependencySet)
           
NominalIntroductionManager.NominalIntroductionBranchingPoint(Tableau tableau, Node rootNode, Node treeNode, AtMostAbstractRoleGuard atMostRoleGuard)