|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| 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)
|
|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||