uk.ac.manchester.cs.jfact.kernel

Class DlCompletionTree

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

Constructor Summary

Constructors

Constructor and Description
DlCompletionTree(int newId, JFactReasonerConfiguration c)

Method Summary

Modifier and Type	Method and Description
void	addConcept(ConceptWDep p, boolean complex) 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	canBlockInit(int c)
void	clearAffected() clear affected flag
int	compareTo(DlCompletionTree o)
List<ConceptWDep>	complexConcepts()
ArrayIntMap	complexConceptsMap()
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	isBlockedBySH(DlCompletionTree p)
boolean	isBlockedBySHI(DLDag dag, DlCompletionTree p)
boolean	isBlockedBySHIQ(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) check if the NODE's and current node's IR are labelled with the same level
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
List<ConceptWDep>	simpleConcepts()
ArrayIntMap	simpleConceptsMap()
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

@Nullable
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,
                       boolean complex)

adds concept P to a label, defined by TAG; update blocked status if necessary

Parameters:

p - p

complex - true if complex concepts sought

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

@Nullable
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

simpleConcepts

public List<ConceptWDep> simpleConcepts()

Returns:

simple concepts

complexConcepts

public List<ConceptWDep> complexConcepts()

Returns:

complex concepts

simpleConceptsMap

public ArrayIntMap simpleConceptsMap()

Returns:

map for label with simple concepts

complexConceptsMap

public ArrayIntMap complexConceptsMap()

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

isBlockedBySH

public boolean isBlockedBySH(DlCompletionTree p)

Parameters:

p - p

Returns:

check blocking condition for SH logic

isBlockedBySHI

public boolean isBlockedBySHI(DLDag dag,
                              DlCompletionTree p)

Parameters:

dag - dag

p - p

Returns:

check blocking condition for SHI logic

isBlockedBySHIQ

public boolean isBlockedBySHIQ(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

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(@Nullable
                            DlCompletionTree blocker,
                            DepSet dep)

mark node purged

Parameters:

blocker - blocker

dep - dep

Returns:

restorer

getEdgeLabelled

@Nullable
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)

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

Parameters:

node - node to check

dep - depset reference

Returns:

true if mergeable

updateIR

@Nullable
 @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 - completion tree

toAdd - depset

Returns:

restorer

compareTo

public int compareTo(@Nullable
                     DlCompletionTree o)

Specified by:

compareTo in interface Comparable<DlCompletionTree>

equals

public boolean equals(@Nullable
                      Object arg0)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

setBlocker

public void setBlocker(@Nullable
                       DlCompletionTree blocker)

Parameters:

blocker - blocker