DlCompletionTree (JFact 4.0.1 API)

java.lang.Object
- uk.ac.manchester.cs.jfact.kernel.DlCompletionTree

All Implemented Interfaces:: Serializable, Comparable<DlCompletionTree>

@PortedFrom(file="dlCompletionTree.h",
            name="DlCompletionTree")
public class DlCompletionTree
extends Object
implements Comparable<DlCompletionTree>, Serializable

completion tree

See Also:: Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int BLOCKABLE_LEVEL
default level for the Blockable node

Fields
Modifier and Type	Field and Description
`static int`	`BLOCKABLE_LEVEL` default level for the Blockable node

Constructor Summary

Constructors
Constructor and Description

DlCompletionTree(int newId, JFactReasonerConfiguration c)

Constructors
Constructor and Description
`DlCompletionTree(int newId, JFactReasonerConfiguration c)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addConcept(ConceptWDep p, DagTag tag)` adds concept P to a label, defined by TAG; update blocked status if necessary
`void`	`addNeighbour(DlCompletionTreeArc p)` add given arc P as a neighbour
`ArrayIntMap`	`beginl_cc_concepts()`
`List<ConceptWDep>`	`beginl_cc()`
`ArrayIntMap`	`beginl_sc_concepts()`
`List<ConceptWDep>`	`beginl_sc()`
`boolean`	`canBlockInit(int C)`
`void`	`clearAffected()` clear affected flag
`int`	`compareTo(DlCompletionTree o)`
`boolean`	`equals(Object arg0)`
`DlCompletionTree`	`getBlocker()`
`DlCompletionTreeArc`	`getEdgeLabelled(Role R, DlCompletionTree node)` check if edge to NODE is labelled by R;
`int`	`getId()`
`int`	`getInit()`
`List<DlCompletionTreeArc>`	`getNeighbour()`
`int`	`getNominalLevel()`
`DlCompletionTree`	`getParentNode()`
`DepSet`	`getPurgeDep()`
`int`	`hashCode()`
`boolean`	`hasParent()`
`void`	`init(int level)`
`boolean`	`initIR(int level, DepSet ds)` init IR with given entry and dep-set;
`boolean`	`isAffected()`
`boolean`	`isBlockableNode()`
`boolean`	`isBlocked()`
`boolean`	`isBlockedBy_SH(DlCompletionTree p)`
`boolean`	`isBlockedBy_SHI(DLDag dag, DlCompletionTree p)`
`boolean`	`isBlockedBy_SHIQ(DLDag dag, DlCompletionTree p)`
`boolean`	`isBlockedPBlockedNominalNodeCached()`
`boolean`	`isCached()`
`boolean`	`isDataNode()`
`boolean`	`isDBlocked()`
`boolean`	`isIBlocked()`
`boolean`	`isIllegallyDBlocked()`
`boolean`	`isLabelledBy(int p)`
`boolean`	`isLoopLabelled(int c)`
`boolean`	`isNominalNode()`
`boolean`	`isPBlocked()`
`DlCompletionTree`	`isSomeApplicable(Role R, int C)` check if SOME rule is applicable; includes transitive SOME support
`CGLabel`	`label()`
`String`	`logNode()`
`boolean`	`needRestore(int restLevel)`
`boolean`	`needSave(int newLevel)`
`boolean`	`nonMergable(DlCompletionTree node, Reference<DepSet> dep)`
`void`	`printBody(LogAdapter o)`
`DlCompletionTree`	`resolvePBlocker()`
`DlCompletionTree`	`resolvePBlocker(DepSet dep)`
`void`	`restore(int level)`
`void`	`save(int level)` save node using internal stack
`void`	`setAffected()` set node (and all subnodes) affected
`void`	`setBlocker(DlCompletionTree blocker)`
`Restorer`	`setCached(boolean val)` set cached status of given node
`void`	`setDataNode()` set data node to true
`Restorer`	`setDBlocked(DlCompletionTree blocker)` mark node d-blocked
`Restorer`	`setIBlocked(DlCompletionTree blocker)` mark node i-blocked
`void`	`setInit(int p)` set the Init concept
`void`	`setNominalLevel()` set nominal level to 0
`void`	`setNominalLevel(int newLevel)`
`Restorer`	`setPBlocked(DlCompletionTree blocker, DepSet dep)` mark node purged
`Restorer`	`setUBlocked()` mark node unblocked
`String`	`toString()`
`Restorer`	`updateIR(DlCompletionTree node, DepSet toAdd)` update IR of the current node with IR from NODE and additional clash-set;

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - BLOCKABLE_LEVEL
```
public static final int BLOCKABLE_LEVEL
```
    default level for the Blockable node
    
    See Also:
    Constant Field Values
- Constructor Detail
  - DlCompletionTree
```
public DlCompletionTree(int newId,
                JFactReasonerConfiguration c)
```
    Parameters:
    newId - newId
    c - c
- Method Detail
  - canBlockInit
```
public boolean canBlockInit(int C)
```
    Parameters:
    C - C
    
    Returns:
    check whether a node can block another one with init concept C
  - addNeighbour
```
public void addNeighbour(DlCompletionTreeArc p)
```
    add given arc P as a neighbour
    
    Parameters:
    p - p
  - getId
```
public int getId()
```
    Returns:
    Node's id
  - isCached
```
public boolean isCached()
```
    Returns:
    check if the node is cached (IE need not to be expanded)
  - setCached
```
public Restorer setCached(boolean val)
```
    set cached status of given node
    
    Parameters:
    val - val
    
    Returns:
    restorer
  - isDataNode
```
public boolean isDataNode()
```
    Returns:
    true if datanode
  - setDataNode
```
public void setDataNode()
```
    set data node to true
  - isBlockableNode
```
public boolean isBlockableNode()
```
    Returns:
    true if blockable
  - isNominalNode
```
public boolean isNominalNode()
```
    Returns:
    true if nominal
  - setNominalLevel
```
public void setNominalLevel()
```
    set nominal level to 0
  - setNominalLevel
```
public void setNominalLevel(int newLevel)
```
    Parameters:
    newLevel - newLevel
  - getNominalLevel
```
public int getNominalLevel()
```
    Returns:
    nominal level
  - addConcept
```
public void addConcept(ConceptWDep p,
              DagTag tag)
```
    adds concept P to a label, defined by TAG; update blocked status if necessary
    
    Parameters:
    p - p
    tag - tag
  - setInit
```
public void setInit(int p)
```
    set the Init concept
    
    Parameters:
    p - p
  - getInit
```
public int getInit()
```
    Returns:
    init value
  - getNeighbour
```
public List<DlCompletionTreeArc> getNeighbour()
```
    Returns:
    neighbour list
  - hasParent
```
public boolean hasParent()
```
    Returns:
    true if node is a non-root; works for reflexive roles
  - isSomeApplicable
```
public DlCompletionTree isSomeApplicable(Role R,
                                int C)
```
    check if SOME rule is applicable; includes transitive SOME support
    
    Parameters:
    R - R
    C - C
    
    Returns:
    completion tree
  - label
```
public CGLabel label()
```
    Returns:
    label
  - beginl_sc
```
public List<ConceptWDep> beginl_sc()
```
    Returns:
    simple concepts
  - beginl_cc
```
public List<ConceptWDep> beginl_cc()
```
    Returns:
    complex concepts
  - beginl_sc_concepts
```
public ArrayIntMap beginl_sc_concepts()
```
    Returns:
    map for label with simple concepts
  - beginl_cc_concepts
```
public ArrayIntMap beginl_cc_concepts()
```
    Returns:
    map for a label with complex concepts
  - isLabelledBy
```
public boolean isLabelledBy(int p)
```
    Parameters:
    p - p
    
    Returns:
    check whether node's label contains P
  - isBlockedBy_SH
```
public boolean isBlockedBy_SH(DlCompletionTree p)
```
    Parameters:
    p - p
    
    Returns:
    check blocking condition for SH logic
  - isBlockedBy_SHI
```
public boolean isBlockedBy_SHI(DLDag dag,
                      DlCompletionTree p)
```
    Parameters:
    dag - dag
    p - p
    
    Returns:
    check blocking condition for SHI logic
  - isBlockedBy_SHIQ
```
public boolean isBlockedBy_SHIQ(DLDag dag,
                       DlCompletionTree p)
```
    Parameters:
    dag - dag
    p - p
    
    Returns:
    check blocking condition for SHIQ logic using optimised blocking
  - getParentNode
```
public DlCompletionTree getParentNode()
```
    Returns:
    RW pointer to the parent node; WARNING: correct only for nodes with hasParent()==TRUE
  - isAffected
```
public boolean isAffected()
```
    Returns:
    check whether node is affected by blocking-related changes
  - setAffected
```
public void setAffected()
```
    set node (and all subnodes) affected
  - clearAffected
```
public void clearAffected()
```
    clear affected flag
  - isDBlocked
```
public boolean isDBlocked()
```
    Returns:
    check if node is directly blocked
  - isIBlocked
```
public boolean isIBlocked()
```
    Returns:
    check if node is indirectly blocked
  - isPBlocked
```
public boolean isPBlocked()
```
    Returns:
    check if node is purged (and so indirectly blocked)
  - isBlockedPBlockedNominalNodeCached
```
public boolean isBlockedPBlockedNominalNodeCached()
```
    Returns:
    true if node is blocked
  - isBlocked
```
public boolean isBlocked()
```
    Returns:
    check if node is blocked (d/i)
  - isIllegallyDBlocked
```
public boolean isIllegallyDBlocked()
```
    Returns:
    check the legality of the direct block
  - getBlocker
```
@Nonnull
public DlCompletionTree getBlocker()
```
    Returns:
    blocker
  - getPurgeDep
```
public DepSet getPurgeDep()
```
    Returns:
    get purge dep-set of a given node
  - resolvePBlocker
```
public DlCompletionTree resolvePBlocker()
```
    Returns:
    get node to which current one was merged
  - resolvePBlocker
```
public DlCompletionTree resolvePBlocker(DepSet dep)
```
    Parameters:
    dep - dep
    
    Returns:
    get node to which current one was merged; fills DEP from pDep's
  - isLoopLabelled
```
public boolean isLoopLabelled(int c)
```
    Parameters:
    c - c
    
    Returns:
    check whether the loop between a DBlocked NODE and it's parent blocked contains C
  - setDBlocked
```
public Restorer setDBlocked(DlCompletionTree blocker)
```
    mark node d-blocked
    
    Parameters:
    blocker - blocker
    
    Returns:
    restorer
  - setIBlocked
```
public Restorer setIBlocked(DlCompletionTree blocker)
```
    mark node i-blocked
    
    Parameters:
    blocker - blocker
    
    Returns:
    restorer
  - setUBlocked
```
public Restorer setUBlocked()
```
    mark node unblocked
    
    Returns:
    restorer
  - setPBlocked
```
public Restorer setPBlocked(DlCompletionTree blocker,
                   DepSet dep)
```
    mark node purged
    
    Parameters:
    blocker - blocker
    dep - dep
    
    Returns:
    restorer
  - getEdgeLabelled
```
public DlCompletionTreeArc getEdgeLabelled(Role R,
                                  DlCompletionTree node)
```
    check if edge to NODE is labelled by R;
    
    Parameters:
    R - R
    node - node
    
    Returns:
    null if does not
  - initIR
```
@PortedFrom(file="dlCompletionTree.cpp",
            name="initIR")
public boolean initIR(int level,
                                DepSet ds)
```
    init IR with given entry and dep-set;
    
    Parameters:
    level - level
    ds - ds
    
    Returns:
    true if IR already has this label
  - needSave
```
public boolean needSave(int newLevel)
```
    Parameters:
    newLevel - newLevel
    
    Returns:
    check if node needs to be saved
  - save
```
public void save(int level)
```
    save node using internal stack
    
    Parameters:
    level - level
  - needRestore
```
public boolean needRestore(int restLevel)
```
    Parameters:
    restLevel - restLevel
    
    Returns:
    check if node needs to be restored
  - restore
```
public void restore(int level)
```
    Parameters:
    level - level number restore node to given level
  - logNode
```
public String logNode()
```
    Returns:
    log node information (number, i/d blockers, cached)
  - init
```
public void init(int level)
```
    Parameters:
    level - level
  - printBody
```
public void printBody(LogAdapter o)
```
    Parameters:
    o - o
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - nonMergable
```
@PortedFrom(file="dlCompletionTree.cpp",
            name="nonMergable")
public boolean nonMergable(DlCompletionTree node,
                                     Reference<DepSet> dep)
```
    Parameters:
    node - node
    dep - dep
    
    Returns:
    check if the NODE's and current node's IR are labelled with the same level
  - updateIR
```
@PortedFrom(file="dlCompletionTree.cpp",
            name="updateIR")
public Restorer updateIR(DlCompletionTree node,
                                   DepSet toAdd)
```
    update IR of the current node with IR from NODE and additional clash-set;
    
    Parameters:
    node - node
    toAdd - toAdd
    
    Returns:
    restorer
  - compareTo
```
public int compareTo(DlCompletionTree o)
```
    Specified by:
    
    compareTo in interface Comparable<DlCompletionTree>
  - equals
```
public boolean equals(Object arg0)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - setBlocker
```
public void setBlocker(DlCompletionTree blocker)
```
    Parameters:
    blocker - blocker

Class DlCompletionTree

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BLOCKABLE_LEVEL

Constructor Detail

DlCompletionTree

Method Detail

canBlockInit

addNeighbour

getId

isCached

setCached

isDataNode

setDataNode

isBlockableNode

isNominalNode

setNominalLevel

setNominalLevel

getNominalLevel

addConcept

setInit

getInit

getNeighbour

hasParent

isSomeApplicable

label

beginl_sc

beginl_cc

beginl_sc_concepts

beginl_cc_concepts

isLabelledBy

isBlockedBy_SH

isBlockedBy_SHI

isBlockedBy_SHIQ

getParentNode

isAffected

setAffected

clearAffected

isDBlocked

isIBlocked

isPBlocked

isBlockedPBlockedNominalNodeCached

isBlocked

isIllegallyDBlocked

getBlocker

getPurgeDep

resolvePBlocker

resolvePBlocker

isLoopLabelled

setDBlocked

setIBlocked

setUBlocked

setPBlocked

getEdgeLabelled

initIR

needSave

save

needRestore

restore

logNode

init

printBody

toString

nonMergable

updateIR

compareTo

equals

hashCode

setBlocker