TermModel (InterProlog Java Bridge)

java.lang.Object
- com.declarativa.interprolog.TermModel

All Implemented Interfaces:

Serializable, TreeModel

Direct Known Subclasses:

InitiallyFlatTermModel
```
public class TermModel
extends Object
implements Serializable, TreeModel
```
Represents a Prolog term, as a tree of TermModel objects, each containing a term node and a children list. Implements TreeModel, therefore easily supporting display in a JTree. It includes the funcionality of Prolog's Edinburgh syntax write within toString(); if you wish to reflect operator declarations dynamically you should provide a different PrologOperatorsContext object

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`TermModel[]`	`children` public for convenience, but should not be set outside this class; children == null means children == new TermModel[0]
`static int`	`listMaxLength`
`Object`	`node` public for convenience, but should not be set outside this class
`TermModel`	`root` The TermModel containing this; relevant to define variable scope.

Constructor Summary

Constructors
Constructor and Description
`TermModel()`
`TermModel(int n)`
`TermModel(Object n)`
`TermModel(Object n, boolean isAList)`
`TermModel(Object n, TermModel[] c)`
`TermModel(Object n, TermModel[] c, boolean isAList)`
`TermModel(Object n, Vector<TermModel> v)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChildren(TermModel[] more)` Add children to this term node; a new children array is created and old children are copied to it
`void`	`addTermModelListener(TermModelListener l)` Start notifying listener l of changes to this term.
`void`	`addTreeModelListener(TreeModelListener l)`
`void`	`assignTermChanges(TermModel other)` Assuming this and the other terms are structurally similar, replaces variable nodes in this term by corresponding nonvar nodes.
`void`	`assignToVar(VariableNode v, Object value)` Replaces all occurrences of v in this subterm by value, using setNodeValue
`Object`	`clone()` Clones by serialization, to keep variable bindings; these should form a closed graph within this term, otherwise the new term instance would contain dangling references
`void`	`deleteChildren(int[] less)` Delete children with specified indexes; a new children array is created and old children are copied to it
`void`	`deleteChildren(TermModel[] less)` Removes the children in array; it finds children to remove by using the equivalent of Prolog's ==.
`void`	`destroy()`
`static void`	`destroy(TermModel[] children)`
`static String`	`doubleQuotes(String S)`
`boolean`	`equals(Object x)` True if both terms are structurally similar with equal nodes.
`static ObjectExamplePair`	`example()`
`static TreePath`	`findPathForNode(String label, TermModel tree, boolean exactMatch)`
`void`	`fireTermChanged()`
`TermModel[]`	`flatList()` Flattens this list into a new TermModel array, but not completely: the result may still contain lists
`static TermModel[]`	`flatList(TermModel list)` Flattens a list into a TermModel array, but not completely: the result may still contain lists
`String`	`flatListToString(PrologOperatorsContext ops, boolean quoted)`
`Object`	`getChild(int index)`
`Object`	`getChild(Object parent, int index)`
`int`	`getChildCount()`
`int`	`getChildCount(Object parent)`
`TermModel[]`	`getChildren()`
`String`	`getFunctorArity()` Return a node/arity String
`int`	`getIndexOfChild(Object parent, Object child)`
`Object`	`getRoot()`
`String`	`getTemplate()` Return a Node(_,..._) String
`int`	`hashCode()` Returns an hashCode for the result of toString()
`int`	`intValue()` Returns node object as an int, assuming it is a Number
`boolean`	`isAtom()`
`boolean`	`isInteger()`
`boolean`	`isLeaf()`
`boolean`	`isLeaf(Object node)`
`boolean`	`isList()` May be an empty list
`boolean`	`isListEnd()`
`boolean`	`isLong()`
`boolean`	`isNumber()`
`boolean`	`isRoot()` This node is its own root
`boolean`	`isVar()`
`String`	`listToString(PrologOperatorsContext ops, boolean quoted)`
`long`	`longValue()` Returns node object as a long, assuming it is a Number
`Vector<Integer>`	`makeIntegerVector()` Assuming this is a list of numbers, returns a Vector containing one Integer for each number in the list
`static TermModel`	`makeList(ArrayList<TermModel> terms)` Make a binary (non flat) list
`static TermModel`	`makeList(TermModel[] terms)` Make a binary (non flat) list
`static TermModel`	`makeList(Vector<TermModel> terms)`
`boolean`	`nodeIsVar()`
`static String`	`parenthesize(boolean yes, String S)`
`int`	`precedence(PrologOperatorsContext context)`
`static Hashtable<String,Object>`	`props2Hashtable(TermModel[] terms)`
`static String`	`quoteIfFirstUpper(String S)`
`static boolean`	`quotesAreNeeded(String atom)`
`void`	`removeTermModelListener(TermModelListener l)`
`void`	`removeTreeModelListener(TreeModelListener l)`
`void`	`setChild(int index, TermModel child)` Set the child, notifying TermModelListeners
`void`	`setChildren(TermModel[] c)` Set the children array, notifying TermModelListeners
`void`	`setNodeValue(Object v)` Set the node, notifying TermModelListeners
`void`	`setRoot()` Set the root variables of nodes in this subterm to refer this term node as their root
`void`	`setRoot(TermModel r)` Set the root variables of nodes in this subterm to refer r as their root
`String`	`toIndentedString()`
`String`	`toIndentedString(int level)`
`String`	`toString()` Returns a close imitation of a Prolog's write, following infix/prefix/postfix operartor declarations.
`String`	`toString(boolean quoted)`
`String`	`toString(PrologEngine engine, boolean quoted)`
`String`	`toString(PrologOperatorsContext ops)`
`String`	`toString(PrologOperatorsContext ops, boolean quoted)` quoted true: emulates writeq, and also ignores operator precedences, using prefix notation; also ignores list size limits, writing the full list.
`boolean`	`unifies(TermModel term)` If two terms, each with nonrepeated variables, are unifiable, this method returns true.
`void`	`valueForPathChanged(TreePath path, Object newValue)`
`boolean`	`variant(TermModel tx)`
`boolean`	`variant(TermModel tx, Map<VariableNode,VariableNode> myVars)`

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

- Field Detail
  - node
```
public Object node
```
    public for convenience, but should not be set outside this class
  - children
```
public TermModel[] children
```
    public for convenience, but should not be set outside this class; children == null means children == new TermModel[0]
  - root
```
public transient TermModel root
```
    The TermModel containing this; relevant to define variable scope. For this to contain the root, the root TermModel must have been messaged once with setRoot()
  - listMaxLength
```
public static final int listMaxLength
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - TermModel
```
public TermModel()
```
  - TermModel
```
public TermModel(Object n)
```
  - TermModel
```
public TermModel(Object n,
                 TermModel[] c)
```
  - TermModel
```
public TermModel(Object n,
                 boolean isAList)
```
  - TermModel
```
public TermModel(Object n,
                 TermModel[] c,
                 boolean isAList)
```
  - TermModel
```
public TermModel(int n)
```
  - TermModel
```
public TermModel(Object n,
                 Vector<TermModel> v)
```
- Method Detail
  - example
```
public static ObjectExamplePair example()
```
  - clone
```
public Object clone()
```
    Clones by serialization, to keep variable bindings; these should form a closed graph within this term, otherwise the new term instance would contain dangling references
    
    Overrides:
    
    clone in class Object
  - equals
```
public boolean equals(Object x)
```
    True if both terms are structurally similar with equal nodes. If nonground...variables will be compared as if with == . Probably what you do NOT want to do.
    
    Overrides:
    
    equals in class Object
  - variant
```
public boolean variant(TermModel tx)
```
  - variant
```
public boolean variant(TermModel tx,
                       Map<VariableNode,VariableNode> myVars)
```
  - setNodeValue
```
public void setNodeValue(Object v)
```
    Set the node, notifying TermModelListeners
  - setChild
```
public void setChild(int index,
                     TermModel child)
```
    Set the child, notifying TermModelListeners
  - setChildren
```
public void setChildren(TermModel[] c)
```
    Set the children array, notifying TermModelListeners
  - getChildren
```
public TermModel[] getChildren()
```
  - addChildren
```
public void addChildren(TermModel[] more)
```
    Add children to this term node; a new children array is created and old children are copied to it
  - deleteChildren
```
public void deleteChildren(int[] less)
```
    Delete children with specified indexes; a new children array is created and old children are copied to it
  - deleteChildren
```
public void deleteChildren(TermModel[] less)
```
    Removes the children in array; it finds children to remove by using the equivalent of Prolog's ==. All "matching" terms will be removed
  - assignToVar
```
public void assignToVar(VariableNode v,
                        Object value)
```
    Replaces all occurrences of v in this subterm by value, using setNodeValue
  - assignTermChanges
```
public void assignTermChanges(TermModel other)
```
    Assuming this and the other terms are structurally similar, replaces variable nodes in this term by corresponding nonvar nodes. If either a (this) node is non var or a (other) node is var, (this) node is left untouched.
  - setRoot
```
public void setRoot()
```
    Set the root variables of nodes in this subterm to refer this term node as their root
  - setRoot
```
public void setRoot(TermModel r)
```
    Set the root variables of nodes in this subterm to refer r as their root
  - isRoot
```
public boolean isRoot()
```
    This node is its own root
  - getTemplate
```
public String getTemplate()
```
    Return a Node(_,..._) String
  - getFunctorArity
```
public String getFunctorArity()
```
    Return a node/arity String
  - getRoot
```
public Object getRoot()
```
    Specified by:
    
    getRoot in interface TreeModel
    
    See Also:
    
    TreeModel
  - getChild
```
public Object getChild(Object parent,
                       int index)
```
    Specified by:
    
    getChild in interface TreeModel
    
    See Also:
    
    TreeModel
  - getChildCount
```
public int getChildCount(Object parent)
```
    Specified by:
    
    getChildCount in interface TreeModel
    
    See Also:
    
    TreeModel
  - isLeaf
```
public boolean isLeaf(Object node)
```
    Specified by:
    
    isLeaf in interface TreeModel
    
    See Also:
    
    TreeModel
  - valueForPathChanged
```
public void valueForPathChanged(TreePath path,
                                Object newValue)
```
    Specified by:
    
    valueForPathChanged in interface TreeModel
    
    See Also:
    
    TreeModel
  - getIndexOfChild
```
public int getIndexOfChild(Object parent,
                           Object child)
```
    Specified by:
    
    getIndexOfChild in interface TreeModel
    
    See Also:
    
    TreeModel
  - addTreeModelListener
```
public void addTreeModelListener(TreeModelListener l)
```
    Specified by:
    
    addTreeModelListener in interface TreeModel
    
    See Also:
    
    TreeModel
  - removeTreeModelListener
```
public void removeTreeModelListener(TreeModelListener l)
```
    Specified by:
    
    removeTreeModelListener in interface TreeModel
    
    See Also:
    
    TreeModel
  - getChild
```
public Object getChild(int index)
```
  - getChildCount
```
public int getChildCount()
```
  - isLeaf
```
public boolean isLeaf()
```
  - addTermModelListener
```
public void addTermModelListener(TermModelListener l)
```
    Start notifying listener l of changes to this term. The term is considered changed iff either a node or children is set to a different object; a nonreported change is the setting of a same object as node/children, not the setting of an "equals" object
  - removeTermModelListener
```
public void removeTermModelListener(TermModelListener l)
```
  - fireTermChanged
```
public void fireTermChanged()
```
  - findPathForNode
```
public static TreePath findPathForNode(String label,
                                       TermModel tree,
                                       boolean exactMatch)
```
  - destroy
```
public void destroy()
```
  - destroy
```
public static void destroy(TermModel[] children)
```
  - makeList
```
public static TermModel makeList(TermModel[] terms)
```
    Make a binary (non flat) list
  - makeList
```
public static TermModel makeList(ArrayList<TermModel> terms)
```
    Make a binary (non flat) list
  - makeList
```
public static TermModel makeList(Vector<TermModel> terms)
```
  - makeIntegerVector
```
public Vector<Integer> makeIntegerVector()
```
    Assuming this is a list of numbers, returns a Vector containing one Integer for each number in the list
  - intValue
```
public int intValue()
```
    Returns node object as an int, assuming it is a Number
  - longValue
```
public long longValue()
```
    Returns node object as a long, assuming it is a Number
  - toString
```
public String toString()
```
    Returns a close imitation of a Prolog's write, following infix/prefix/postfix operartor declarations. However it does NOT add the necessary parenthesis according to precedence declarations; if this is a problem use toString(true) instead
    
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(boolean quoted)
```
  - toString
```
public String toString(PrologOperatorsContext ops)
```
  - quotesAreNeeded
```
public static boolean quotesAreNeeded(String atom)
```
  - toString
```
public String toString(PrologOperatorsContext ops,
                       boolean quoted)
```
    quoted true: emulates writeq, and also ignores operator precedences, using prefix notation; also ignores list size limits, writing the full list. For efficiency (and laziness...) more atoms are quoted than necessary; if improvements are needed, inspiration for quotesAreNeeded above is to be found in function quotes_are_needed() in io_builtins_xsb.c
  - toIndentedString
```
public String toIndentedString()
```
  - toIndentedString
```
public String toIndentedString(int level)
```
  - parenthesize
```
public static String parenthesize(boolean yes,
                                  String S)
```
  - doubleQuotes
```
public static String doubleQuotes(String S)
```
  - quoteIfFirstUpper
```
public static String quoteIfFirstUpper(String S)
```
  - toString
```
public String toString(PrologEngine engine,
                       boolean quoted)
```
  - listToString
```
public String listToString(PrologOperatorsContext ops,
                           boolean quoted)
```
  - flatListToString
```
public String flatListToString(PrologOperatorsContext ops,
                               boolean quoted)
```
  - isListEnd
```
public boolean isListEnd()
```
  - isList
```
public boolean isList()
```
    May be an empty list
  - isAtom
```
public boolean isAtom()
```
  - isNumber
```
public boolean isNumber()
```
  - isInteger
```
public boolean isInteger()
```
  - isLong
```
public boolean isLong()
```
  - isVar
```
public boolean isVar()
```
  - nodeIsVar
```
public boolean nodeIsVar()
```
  - flatList
```
public TermModel[] flatList()
```
    Flattens this list into a new TermModel array, but not completely: the result may still contain lists
  - flatList
```
public static TermModel[] flatList(TermModel list)
```
    Flattens a list into a TermModel array, but not completely: the result may still contain lists
  - props2Hashtable
```
public static Hashtable<String,Object> props2Hashtable(TermModel[] terms)
```
  - unifies
```
public boolean unifies(TermModel term)
```
    If two terms, each with nonrepeated variables, are unifiable, this method returns true. So this is NOT a unification test. Doesn't change the terms.
  - hashCode
```
public int hashCode()
```
    Returns an hashCode for the result of toString()
    
    Overrides:
    
    hashCode in class Object
  - precedence
```
public int precedence(PrologOperatorsContext context)
```

Class TermModel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

node

children

root

listMaxLength

Constructor Detail

TermModel

TermModel

TermModel

TermModel

TermModel

TermModel

TermModel

Method Detail

example

clone

equals

variant

variant

setNodeValue

setChild

setChildren

getChildren

addChildren

deleteChildren

deleteChildren

assignToVar

assignTermChanges

setRoot

setRoot

isRoot

getTemplate

getFunctorArity

getRoot

getChild

getChildCount

isLeaf

valueForPathChanged

getIndexOfChild

addTreeModelListener

removeTreeModelListener

getChild

getChildCount

isLeaf

addTermModelListener

removeTermModelListener

fireTermChanged

findPathForNode

destroy

destroy

makeList

makeList

makeList

makeIntegerVector

intValue

longValue

toString

toString

toString

quotesAreNeeded

toString

toIndentedString

toIndentedString

parenthesize

doubleQuotes

quoteIfFirstUpper

toString

listToString

flatListToString

isListEnd

isList

isAtom

isNumber

isInteger

isLong