Node (Pellet :: Core 2.5.2-dllearner API)

java.lang.Object
- org.mindswap.pellet.Node

Direct Known Subclasses:

Individual, Literal
```
public abstract class Node
extends Object
```
Author:

Evren Sirin

Field Summary

Fields
Modifier and Type	Field and Description
`protected ABox`	`abox`
`static int`	`ALL`
`static int`	`ATOM`
`static int`	`BLOCKABLE`
`static int`	`CHANGED`
`protected Map<aterm.ATermAppl,DependencySet>`	`depends`
`protected Map<Node,DependencySet>`	`differents`
`protected EdgeList`	`inEdges`
`static Logger`	`log`
`static int`	`MAX`
`protected Set<Node>`	`merged` Set of other nodes that have been merged to this node.
`protected DependencySet`	`mergeDepends` Dependency information about why merged happened (if at all)
`protected Node`	`mergedTo` If this node is merged to another one, points to that node otherwise points to itself.
`static int`	`MIN`
`protected aterm.ATermAppl`	`name`
`static int`	`NOM`
`static int`	`NOMINAL`
`static int`	`OR`
`protected DependencySet`	`pruned`
`static int`	`SOME`
`static int`	`TYPES`
`static int`	`UNCHANGED`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Node(aterm.ATermAppl name, ABox abox)

protected Node(Node node, ABox abox)

Constructors
Modifier	Constructor and Description
`protected`	`Node(aterm.ATermAppl name, ABox abox)`
`protected`	`Node(Node node, ABox abox)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addInEdge(Edge edge)`
`void`	`addType(aterm.ATermAppl c, DependencySet ds)`
`abstract Node`	`copyTo(ABox abox)`
`boolean`	`equals(Object obj)`
`ABox`	`getABox()` getABox
`Map<Node,DependencySet>`	`getAllMerged()`
`Map<aterm.ATermAppl,DependencySet>`	`getDepends()`
`DependencySet`	`getDepends(aterm.ATerm c)`
`DependencySet`	`getDifferenceDependency(Node node)`
`Set<Node>`	`getDifferents()`
`EdgeList`	`getInEdges()`
`Set<Node>`	`getMerged()`
`DependencySet`	`getMergeDependency(boolean all)` Get the dependency if this node is merged to another node.
`Node`	`getMergedTo()`
`aterm.ATermAppl`	`getName()`
`String`	`getNameStr()`
`abstract DependencySet`	`getNodeDepends()`
`abstract int`	`getNominalLevel()`
`List<aterm.ATermAppl>`	`getPath()` A string that identifies this node either using its name or the path of individuals that comes to this node.
`DependencySet`	`getPruned()`
`Node`	`getSame()`
`abstract aterm.ATermAppl`	`getTerm()`
`Set<aterm.ATermAppl>`	`getTypes()`
`int`	`hashCode()`
`Bool`	`hasObviousType(aterm.ATermAppl c)`
`boolean`	`hasObviousType(Collection<aterm.ATermAppl> coll)`
`abstract boolean`	`hasSuccessor(Node x)`
`boolean`	`hasType(aterm.ATerm c)`
`void`	`inheritDifferents(Node y, DependencySet ds)`
`abstract boolean`	`isBlockable()`
`boolean`	`isBnode()`
`boolean`	`isConceptRoot()` Returns true if this is the node created for the concept satisfiability check.
`boolean`	`isDifferent(Node node)`
`abstract boolean`	`isIndividual()`
`abstract boolean`	`isLeaf()`
`abstract boolean`	`isLiteral()`
`boolean`	`isMerged()`
`boolean`	`isNamedIndividual()`
`abstract boolean`	`isNominal()`
`boolean`	`isPruned()`
`boolean`	`isRoot()`
`boolean`	`isRootNominal()`
`boolean`	`isSame(Node node)`
`int`	`mergedAt()`
`abstract void`	`prune(DependencySet ds)`
`int`	`prunedAt()`
`boolean`	`removeInEdge(Edge edge)`
`void`	`removeInEdges()`
`boolean`	`removeType(aterm.ATermAppl c)`
`void`	`removeTypes()`
`void`	`reset(boolean onlyApplyTypes)`
`protected void`	`resetTypes()`
`boolean`	`restore(int branch)`
`Boolean`	`restorePruned(int branch)`
`void`	`setChanged(int type)` Indicates that node has been changed in a way that requires us to recheck the concepts of given type.
`void`	`setConceptRoot(boolean isConceptRoot)`
`boolean`	`setDifferent(Node node, DependencySet ds)`
`boolean`	`setSame(Node node, DependencySet ds)`
`String`	`toString()`
`void`	`undoSetSame()`
`void`	`unprune(int branch)`
`protected void`	`updateNodeReferences()`

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

Field Detail
- log
```
public static final Logger log
```
- BLOCKABLE
```
public static final int BLOCKABLE
```
  See Also:
  
  Constant Field Values
- NOMINAL
```
public static final int NOMINAL
```
  See Also:
  
  Constant Field Values
- CHANGED
```
public static final int CHANGED
```
  See Also:
  
  Constant Field Values
- UNCHANGED
```
public static final int UNCHANGED
```
  See Also:
  
  Constant Field Values
- ATOM
```
public static final int ATOM
```
  See Also:
  
  Constant Field Values
- OR
```
public static final int OR
```
  See Also:
  
  Constant Field Values
- SOME
```
public static final int SOME
```
  See Also:
  
  Constant Field Values
- ALL
```
public static final int ALL
```
  See Also:
  
  Constant Field Values
- MIN
```
public static final int MIN
```
  See Also:
  
  Constant Field Values
- MAX
```
public static final int MAX
```
  See Also:
  
  Constant Field Values
- NOM
```
public static final int NOM
```
  See Also:
  
  Constant Field Values
- TYPES
```
public static final int TYPES
```
  See Also:
  
  Constant Field Values
- abox
```
protected ABox abox
```
- name
```
protected aterm.ATermAppl name
```
- depends
```
protected Map<aterm.ATermAppl,DependencySet> depends
```
- mergedTo
```
protected Node mergedTo
```
  If this node is merged to another one, points to that node otherwise points to itself. This is a linked list implementation of disjoint-union data structure.
- inEdges
```
protected EdgeList inEdges
```
- mergeDepends
```
protected DependencySet mergeDepends
```
  Dependency information about why merged happened (if at all)
- pruned
```
protected DependencySet pruned
```
- merged
```
protected Set<Node> merged
```
  Set of other nodes that have been merged to this node. Note that this is only the set of nodes directly merged to this one. A recursive traversal is required to get all the merged nodes.
- differents
```
protected Map<Node,DependencySet> differents
```

Constructor Detail

Node

protected Node(aterm.ATermAppl name,
               ABox abox)

Node

protected Node(Node node,
               ABox abox)

Method Detail

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

updateNodeReferences
```
protected void updateNodeReferences()
```

setChanged
```
public void setChanged(int type)
```
Indicates that node has been changed in a way that requires us to recheck the concepts of given type.

Parameters:

type - type of concepts that need to be rechecked

isConceptRoot
```
public boolean isConceptRoot()
```
Returns true if this is the node created for the concept satisfiability check.

Returns:

setConceptRoot

public void setConceptRoot(boolean isConceptRoot)

isBnode
```
public boolean isBnode()
```

isNamedIndividual
```
public boolean isNamedIndividual()
```

isRoot
```
public boolean isRoot()
```

isLeaf
```
public abstract boolean isLeaf()
```

isRootNominal
```
public boolean isRootNominal()
```

copyTo

public abstract Node copyTo(ABox abox)

addInEdge
```
protected void addInEdge(Edge edge)
```

getInEdges
```
public EdgeList getInEdges()
```

removeInEdge

public boolean removeInEdge(Edge edge)

removeInEdges
```
public void removeInEdges()
```

reset

public void reset(boolean onlyApplyTypes)

resetTypes
```
protected void resetTypes()
```

restorePruned

public Boolean restorePruned(int branch)

restore
```
public boolean restore(int branch)
```

addType

public void addType(aterm.ATermAppl c,
                    DependencySet ds)

removeType

public boolean removeType(aterm.ATermAppl c)

hasType

public boolean hasType(aterm.ATerm c)

hasObviousType

public Bool hasObviousType(aterm.ATermAppl c)

hasObviousType

public boolean hasObviousType(Collection<aterm.ATermAppl> coll)

hasSuccessor

public abstract boolean hasSuccessor(Node x)

getNodeDepends

public abstract DependencySet getNodeDepends()

getDepends

public DependencySet getDepends(aterm.ATerm c)

getDepends

public Map<aterm.ATermAppl,DependencySet> getDepends()

getTypes

public Set<aterm.ATermAppl> getTypes()

removeTypes
```
public void removeTypes()
```

prunedAt
```
public int prunedAt()
```

isPruned
```
public boolean isPruned()
```

getPruned
```
public DependencySet getPruned()
```

prune

public abstract void prune(DependencySet ds)

unprune
```
public void unprune(int branch)
```

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

isNominal
```
public abstract boolean isNominal()
```

isBlockable
```
public abstract boolean isBlockable()
```

isLiteral
```
public abstract boolean isLiteral()
```

isIndividual

public abstract boolean isIndividual()

mergedAt
```
public int mergedAt()
```

isMerged
```
public boolean isMerged()
```

getMergedTo
```
public Node getMergedTo()
```

getMergeDependency
```
public DependencySet getMergeDependency(boolean all)
```
Get the dependency if this node is merged to another node. This node may be merged to another node which is later merged to another node and so on. This function may return the dependency for the first step or the union of all steps.

getSame
```
public Node getSame()
```

undoSetSame
```
public void undoSetSame()
```

getMerged
```
public Set<Node> getMerged()
```

getAllMerged

public Map<Node,DependencySet> getAllMerged()

setSame

public boolean setSame(Node node,
                       DependencySet ds)

isSame
```
public boolean isSame(Node node)
```

isDifferent

public boolean isDifferent(Node node)

getDifferents
```
public Set<Node> getDifferents()
```

getDifferenceDependency

public DependencySet getDifferenceDependency(Node node)

setDifferent

public boolean setDifferent(Node node,
                            DependencySet ds)

inheritDifferents

public void inheritDifferents(Node y,
                              DependencySet ds)

getName
```
public aterm.ATermAppl getName()
```

getTerm

public abstract aterm.ATermAppl getTerm()

getNameStr
```
public String getNameStr()
```

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

toString in class Object

getPath
```
public List<aterm.ATermAppl> getPath()
```
A string that identifies this node either using its name or the path of individuals that comes to this node. For example, a node that has been generated by the completion rules needs to be identified with respect to a named individual. Ultimately, we need the shortest path or something like that but right now we just use the first inEdge

Returns:

getABox
```
public ABox getABox()
```
getABox

Returns:

Class Node

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

BLOCKABLE

NOMINAL

CHANGED

UNCHANGED

ATOM

OR

SOME

ALL

MIN

MAX

NOM

TYPES

abox

name

depends

mergedTo

inEdges

mergeDepends

pruned

merged

differents

Constructor Detail

Node

Node

Method Detail

hashCode

equals

updateNodeReferences

setChanged

isConceptRoot

setConceptRoot

isBnode

isNamedIndividual

isRoot

isLeaf

isRootNominal

copyTo

addInEdge

getInEdges

removeInEdge

removeInEdges

reset

resetTypes

restorePruned

restore

addType

removeType

hasType

hasObviousType

hasObviousType

hasSuccessor

getNodeDepends

getDepends

getDepends

getTypes

removeTypes

prunedAt

isPruned

getPruned

prune

unprune

getNominalLevel

isNominal

isBlockable

isLiteral

isIndividual

mergedAt

isMerged

getMergedTo

getMergeDependency

getSame

undoSetSame

getMerged