DlCompletionTree (JFact 1.0.0 API)

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

All Implemented Interfaces:: Comparable<DlCompletionTree>

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

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BLOCKABLE_LEVEL` default level for the Blockable node
`protected DlCompletionTree`	`blocker` blocker of a node
`protected boolean`	`cached` flag if node is Cached
`protected int`	`curLevel`
`protected boolean`	`dBlocked` flag whether node is directly/indirectly blocked
`protected List<ConceptWDep>`	`inequalityRelation` inequality relation information respecting current node
`protected Map<Integer,ConceptWDep>`	`inequalityRelation_helper`
`protected boolean`	`pBlocked` flag whether node is permanently/temporarily blocked
`protected DepSet`	`pDep` dep-set for Purge op

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
`boolean`	`B2Complex(RAStateTransitions RST, int C)`
`ArrayIntMap`	`beginl_cc_concepts()` begin() iterator for a label with complex concepts
`List<ConceptWDep>`	`beginl_cc()` begin() iterator for a label with complex concepts
`ArrayIntMap`	`beginl_sc_concepts()` begin() iterator for a label with simple concepts
`List<ConceptWDep>`	`beginl_sc()` begin() iterator for a label with simple concepts
`boolean`	`canBlockInit(int C)` check whether a node can block another one with init concept C
`void`	`clearAffected()` clear affected flag
`int`	`compareTo(DlCompletionTree o)`
`boolean`	`equals(Object arg0)`
`DlCompletionTree`	`getBlocker()` get access to the blocker
`DlCompletionTreeArc`	`getEdgeLabelled(Role R, DlCompletionTree node)` check if edge to NODE is labelled by R; return null if does not
`int`	`getId()` get Node's id
`int`	`getInit()`
`List<DlCompletionTreeArc>`	`getNeighbour()`
`int`	`getNominalLevel()`
`DlCompletionTree`	`getParentNode()` return RW pointer to the parent node; WARNING: correct only for nodes with hasParent()==TRUE
`DepSet`	`getPurgeDep()` get purge dep-set of a given node
`int`	`hashCode()`
`boolean`	`hasParent()` return true if node is a non-root; works for reflexive roles
`void`	`init(int level)`
`boolean`	`initIR(int level, DepSet ds)` init IR with given entry and dep-set; @return true if IR already has this label
`boolean`	`isAffected()` check whether node is affected by blocking-related changes
`boolean`	`isBlockableNode()`
`boolean`	`isBlocked()` check if node is blocked (d/i)
`boolean`	`isBlockedBy_SH(DlCompletionTree p)` check blocking condition for SH logic
`boolean`	`isBlockedBy_SHI(DLDag dag, DlCompletionTree p)` check blocking condition for SHI logic
`boolean`	`isBlockedBy_SHIQ(DLDag dag, DlCompletionTree p)` check blocking condition for SHIQ logic using optimised blocking
`boolean`	`isBlockedPBlockedNominalNodeCached()`
`boolean`	`isCached()` check if the node is cached (IE need not to be expanded)
`boolean`	`isDataNode()`
`boolean`	`isDBlocked()` check if node is directly blocked
`boolean`	`isIBlocked()` check if node is indirectly blocked
`boolean`	`isIllegallyDBlocked()` check the legality of the direct block
`boolean`	`isLabelledBy(int p)` check whether node's label contains P
`boolean`	`isLoopLabelled(int c)` check whether the loop between a DBlocked NODE and it's parent blocked contains C
`boolean`	`isNominalNode()`
`boolean`	`isPBlocked()` check if node is purged (and so indirectly blocked)
`DlCompletionTree`	`isSomeApplicable(Role R, int C)` check if SOME rule is applicable; includes transitive SOME support
`CGLabel`	`label()` RW access to a label
`String`	`logNode()` log node information (number, i/d blockers, cached)
`boolean`	`needRestore(int restLevel)` check if node needs to be restored
`boolean`	`needSave(int newLevel)` check if node needs to be saved
`boolean`	`nonMergable(DlCompletionTree node, Reference<DepSet> dep)` check if the NODE's and current node's IR are labelled with the same level
`void`	`printBody(LogAdapter o)`
`DlCompletionTree`	`resolvePBlocker()` get node to which current one was merged
`DlCompletionTree`	`resolvePBlocker(DepSet dep)` get node to which current one was merged; fills DEP from pDep's
`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()`
`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()`
`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; @return restorer

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

Field Detail
- inequalityRelation
```
protected List<ConceptWDep> inequalityRelation
```
  inequality relation information respecting current node
- inequalityRelation_helper
```
protected Map<Integer,ConceptWDep> inequalityRelation_helper
```
- blocker
```
protected DlCompletionTree blocker
```
  blocker of a node
- pDep
```
protected DepSet pDep
```
  dep-set for Purge op
- curLevel
```
protected int curLevel
```
- cached
```
protected boolean cached
```
  flag if node is Cached
- pBlocked
```
protected boolean pBlocked
```
  flag whether node is permanently/temporarily blocked
- dBlocked
```
protected boolean dBlocked
```
  flag whether node is directly/indirectly blocked
- BLOCKABLE_LEVEL
```
public static int BLOCKABLE_LEVEL
```
  default level for the Blockable node

Constructor Detail

DlCompletionTree

public DlCompletionTree(int newId,
                JFactReasonerConfiguration c)

Method Detail

canBlockInit
```
public boolean canBlockInit(int C)
```
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

getId
```
public int getId()
```
get Node's id

isCached
```
public boolean isCached()
```
check if the node is cached (IE need not to be expanded)

setCached

public Restorer setCached(boolean val)

set cached status of given node

isDataNode
```
public boolean isDataNode()
```

setDataNode
```
public void setDataNode()
```

isBlockableNode
```
public boolean isBlockableNode()
```

isNominalNode
```
public boolean isNominalNode()
```

setNominalLevel
```
public void setNominalLevel()
```

setNominalLevel

public void setNominalLevel(int newLevel)

getNominalLevel
```
public int getNominalLevel()
```

addConcept
```
public void addConcept(ConceptWDep p,
              DagTag tag)
```
adds concept P to a label, defined by TAG; update blocked status if necessary

setInit
```
public void setInit(int p)
```
set the Init concept

getInit
```
public int getInit()
```

getNeighbour

public List<DlCompletionTreeArc> getNeighbour()

hasParent
```
public boolean hasParent()
```
return 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

label
```
public CGLabel label()
```
RW access to a label

beginl_sc
```
public List<ConceptWDep> beginl_sc()
```
begin() iterator for a label with simple concepts

beginl_cc
```
public List<ConceptWDep> beginl_cc()
```
begin() iterator for a label with complex concepts

beginl_sc_concepts
```
public ArrayIntMap beginl_sc_concepts()
```
begin() iterator for a label with simple concepts

beginl_cc_concepts
```
public ArrayIntMap beginl_cc_concepts()
```
begin() iterator for a label with complex concepts

isLabelledBy
```
public boolean isLabelledBy(int p)
```
check whether node's label contains P

isBlockedBy_SH

public boolean isBlockedBy_SH(DlCompletionTree p)

check blocking condition for SH logic

isBlockedBy_SHI

public boolean isBlockedBy_SHI(DLDag dag,
                      DlCompletionTree p)

check blocking condition for SHI logic

isBlockedBy_SHIQ

public boolean isBlockedBy_SHIQ(DLDag dag,
                       DlCompletionTree p)

check blocking condition for SHIQ logic using optimised blocking

getParentNode
```
public DlCompletionTree getParentNode()
```
return RW pointer to the parent node; WARNING: correct only for nodes with hasParent()==TRUE

isAffected
```
public boolean isAffected()
```
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()
```
check if node is directly blocked

isIBlocked
```
public boolean isIBlocked()
```
check if node is indirectly blocked

isPBlocked
```
public boolean isPBlocked()
```
check if node is purged (and so indirectly blocked)

isBlockedPBlockedNominalNodeCached

public boolean isBlockedPBlockedNominalNodeCached()

isBlocked
```
public boolean isBlocked()
```
check if node is blocked (d/i)

isIllegallyDBlocked
```
public boolean isIllegallyDBlocked()
```
check the legality of the direct block

getBlocker
```
public DlCompletionTree getBlocker()
```
get access to the blocker

getPurgeDep
```
public DepSet getPurgeDep()
```
get purge dep-set of a given node

resolvePBlocker
```
public DlCompletionTree resolvePBlocker()
```
get node to which current one was merged

resolvePBlocker
```
public DlCompletionTree resolvePBlocker(DepSet dep)
```
get node to which current one was merged; fills DEP from pDep's

isLoopLabelled
```
public boolean isLoopLabelled(int c)
```
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

setIBlocked

public Restorer setIBlocked(DlCompletionTree blocker)

mark node i-blocked

setUBlocked
```
public Restorer setUBlocked()
```
mark node unblocked

setPBlocked

public Restorer setPBlocked(DlCompletionTree blocker,
                   DepSet dep)

mark node purged

getEdgeLabelled

public DlCompletionTreeArc getEdgeLabelled(Role R,
                                  DlCompletionTree node)

check if edge to NODE is labelled by R; return null if does not

initIR
```
public boolean initIR(int level,
             DepSet ds)
```
init IR with given entry and dep-set; @return true if IR already has this label

needSave

public boolean needSave(int newLevel)

check if node needs to be saved

save
```
public void save(int level)
```
save node using internal stack

needRestore
```
public boolean needRestore(int restLevel)
```
check if node needs to be restored

logNode
```
public String logNode()
```
log node information (number, i/d blockers, cached)

B2Complex

public boolean B2Complex(RAStateTransitions RST,
                int C)

init
```
public void init(int level)
```

printBody
```
public void printBody(LogAdapter o)
```

toString
```
public String toString()
```
Overrides:

toString in class Object

nonMergable

public boolean nonMergable(DlCompletionTree node,
                  Reference<DepSet> dep)

check if the NODE's and current node's IR are labelled with the same level

updateIR

public Restorer updateIR(DlCompletionTree node,
                DepSet toAdd)

update IR of the current node with IR from NODE and additional clash-set; @return 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)

Class DlCompletionTree

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

inequalityRelation

inequalityRelation_helper

blocker

pDep

curLevel

cached

pBlocked

dBlocked

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

logNode

B2Complex

init

printBody

toString

nonMergable

updateIR

compareTo

equals

hashCode

setBlocker