Term (JPC 0.0.1-alpha-SNAPSHOT API)

java.lang.Object
- org.jpc.term.Term

Direct Known Subclasses:

AbstractVar, Atom, Compound, JRef, NumberTerm
```
public abstract class Term
extends Object
```
Implementations of this interface are Java representations of Prolog Terms (i.e., Prolog data types) Disclaimer: First versions of this class had some methods inspired or taken from the JPL library (specially method comments). Although the current version has diverged enough to be considered a new implementation, some method comments may still be quite similar, with minor adaptations, as they were originally found in the JPL library.

Author:

scastro

Constructor Summary

Constructors
Constructor and Description

Term()

Constructors
Constructor and Description
`Term()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`accept(TermVisitor termVisitor)` Accepts a Jpc term visitor.
`Term`	`arg(int i)` Returns the ith argument (if any) of this Term.
`int`	`arity()` Returns the arity (i.e., number of arguments) of this Term.
`ListTerm`	`asList()` Returns a list representation of this term.
`protected boolean`	`basicIsList()`
`protected abstract void`	`basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)`
`boolean`	`canUnify(Term term)`
`Term`	`changeVariablesNames(Map<String,String> map)` Replace all the variable names according to the map parameter
`Term`	`compile()`
`Term`	`compile(boolean preserveVarNames)`
`Term`	`compile(boolean preserveVarNames, Environment env)`
`Term`	`compile(Environment env)`
`Term`	`compileAndUnify(Term term)`
`Map<String,Term>`	`compileAndUnifyVars(Term term)`
`List<Term>`	`getArgs()` Returns the arguments list of this term.
`List<AbstractVar>`	`getNamedVariables()` Returns a list with all the named variables (i.e., all variables but "_")
`List<String>`	`getNamedVariablesNames()` Returns a list with all the named variables names (i.e., all variables but "_")
`List<String>`	`getNonUnderscoreVariableNames()`
`List<AbstractVar>`	`getNonUnderscoreVariables()`
`List<String>`	`getVariableNames()`
`List<AbstractVar>`	`getVariables()`
`boolean`	`hasFunctor(boolean nameTermObject, int arity)`
`boolean`	`hasFunctor(double nameTermObject, int arity)`
`abstract boolean`	`hasFunctor(Functor functor)` Whether this term has a given functor.
`boolean`	`hasFunctor(long nameTermObject, int arity)`
`boolean`	`hasFunctor(String nameTermObject, int arity)`
`boolean`	`hasVariable(String variableName)` whether the term has a variable with a given id
`abstract boolean`	`isGround()`
`boolean`	`isHilog()`
`boolean`	`isList()` whether this Term is a list
`int`	`listLength()` the length of this list, iff it is one, else an exception is thrown
`abstract Term`	`preCompile(Environment env)`
`Term`	`prepareForFrame()` Method only required for internal usage of the JPC Prolog engine.
`abstract Term`	`prepareForFrame(Environment env)`
`Term`	`prepareForQuery()`
`abstract Term`	`prepareForQuery(Environment env)`
`void`	`read(TermContentHandler contentHandler)`
`void`	`read(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)`
`Term`	`replaceVariables(Map<String,? extends Term> map)` Returns a term with all the occurrences of the variables in the parameter map replaced with its associated value (converted to a term)
`Term`	`resolveBindings()`
`static boolean`	`termEquals(List<? extends Term> list1, List<? extends Term> list2)`
`boolean`	`termEquals(Term t)` Test if this object is equivalent to the term representation of the object sent as parameter This is not testing for equality in a mathematical sense, for example: 'new Variable("_").equals(new Variable("_"))' is false, since both the receiver and the arguments are anonymous variables, not the same variable.
`Term`	`termExpansion(com.google.common.base.Function<Term,Term> termExpander)`
`abstract String`	`toEscapedString()`
`static <T extends Term> String`	`toEscapedString(List<T> terms)` Converts a list of Terms to a String.
`static <T extends Term> String`	`toEscapedString(T... terms)` Converts an array of Terms to its escaped String representation.
`String`	`toString()` Reads the contents of this term (i.e., generates events) to a content handler
`abstract String`	`toString(OperatorsContext operatorsContext)`
`void`	`unify(Term term)`
`Term`	`unifyAndBind(Term term)`
`Map<String,Term>`	`varBindings()`

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

- Constructor Detail
  - Term
```
public Term()
```
- Method Detail
  - isHilog
```
public boolean isHilog()
```
    Returns:
    
    true if the term is a proper Hilog term (i.e., a Hilog term that is not a Prolog term)
  - arg
```
public Term arg(int i)
```
    Returns the ith argument (if any) of this Term. Arguments are counted from 1. throws an IndexOutOfBoundsException if i is inappropriate.
    
    Returns:
    
    the ith argument (counting from one) of this Term.
  - getArgs
```
public List<Term> getArgs()
```
    Returns the arguments list of this term. If the term has no arguments will return an empty list
    
    Returns:
    
    the arguments of this term
  - arity
```
public int arity()
```
    Returns the arity (i.e., number of arguments) of this Term.
    
    Returns:
    
    the arity (1+) of this Term. Returns 0 if the term does not have any arguments (i.e., the Term is an instance of Compound)
  - hasFunctor
```
public abstract boolean hasFunctor(Functor functor)
```
    Whether this term has a given functor.
    
    Parameters:
    
    functor - the functor of this term.
    
    Returns:
    
    true if the term has the given functor. False otherwise.
  - hasFunctor
```
public boolean hasFunctor(String nameTermObject,
                          int arity)
```
  - hasFunctor
```
public boolean hasFunctor(boolean nameTermObject,
                          int arity)
```
  - hasFunctor
```
public boolean hasFunctor(double nameTermObject,
                          int arity)
```
  - hasFunctor
```
public boolean hasFunctor(long nameTermObject,
                          int arity)
```
  - isList
```
public final boolean isList()
```
    whether this Term is a list
    
    Returns:
    
    whether this Term is a list
  - basicIsList
```
protected boolean basicIsList()
```
  - asList
```
public ListTerm asList()
```
    Returns a list representation of this term. Throws an exception if the term cannot be converted to a list (if it is not either the atom '[]' or a cons compound term)
    
    Returns:
    
    a list representation of this term.
  - listLength
```
public int listLength()
```
    the length of this list, iff it is one, else an exception is thrown
    
    Returns:
    
    the length (as an int) of this list, iff it is one
    
    Throws:
    
    LException
  - isGround
```
public abstract boolean isGround()
```
    Returns:
    
    true if the term is ground (it does not have unbound variables). false otherwise.
  - replaceVariables
```
public Term replaceVariables(Map<String,? extends Term> map)
```
    Returns a term with all the occurrences of the variables in the parameter map replaced with its associated value (converted to a term)
    
    Parameters:
    
    map - maps variable names to values.
    
    Returns:
    
    a new term with its variables replaced according to the map
  - changeVariablesNames
```
public Term changeVariablesNames(Map<String,String> map)
```
    Replace all the variable names according to the map parameter
    
    Parameters:
    
    map - maps variable names to new names
    
    Returns:
    
    a new term with its variables renamed according to the map
  - hasVariable
```
public boolean hasVariable(String variableName)
```
    whether the term has a variable with a given id
    
    Parameters:
    
    variableName - the variable id that is queried
    
    Returns:
    
    whether the term has a variable with a given id
  - getVariables
```
public List<AbstractVar> getVariables()
```
    Returns:
    
    the variables names present in the term
  - getVariableNames
```
public List<String> getVariableNames()
```
    Returns:
    
    the variables names present in the term
  - getNonUnderscoreVariables
```
public List<AbstractVar> getNonUnderscoreVariables()
```
    Returns:
    
    a list with all the non underscore variables (i.e., all variables that do not start with "_")
  - getNonUnderscoreVariableNames
```
public List<String> getNonUnderscoreVariableNames()
```
    Returns:
    
    a list with all the variables that do not start with "_".
  - getNamedVariables
```
public List<AbstractVar> getNamedVariables()
```
    Returns a list with all the named variables (i.e., all variables but "_")
    
    Returns:
    
    a list with all the named variables (i.e., all variables but "_")
  - getNamedVariablesNames
```
public List<String> getNamedVariablesNames()
```
    Returns a list with all the named variables names (i.e., all variables but "_")
    
    Returns:
    
    a list with all the named variables names (i.e., all variables but "_")
  - accept
```
public abstract void accept(TermVisitor termVisitor)
```
    Accepts a Jpc term visitor.
    
    Parameters:
    
    termVisitor - the accepted visitor
  - termExpansion
```
public Term termExpansion(com.google.common.base.Function<Term,Term> termExpander)
```
  - read
```
public void read(TermContentHandler contentHandler)
```
  - read
```
public void read(TermContentHandler contentHandler,
                 com.google.common.base.Function<Term,Term> termExpander)
```
  - basicRead
```
protected abstract void basicRead(TermContentHandler contentHandler,
                                  com.google.common.base.Function<Term,Term> termExpander)
```
  - termEquals
```
public boolean termEquals(Term t)
```
    Test if this object is equivalent to the term representation of the object sent as parameter This is not testing for equality in a mathematical sense, for example: 'new Variable("_").equals(new Variable("_"))' is false, since both the receiver and the arguments are anonymous variables, not the same variable. But: 'new Variable("_").termEquals(new Variable("_"))' is true, since they both have the same term representation
    
    Parameters:
    
    termAdaptable -
    
    Returns:
  - termEquals
```
public static boolean termEquals(List<? extends Term> list1,
                                 List<? extends Term> list2)
```
    Parameters:
    
    list1 - a list of Terms
    
    list2 - another list of Terms
    
    Returns:
    
    true if all of the Terms in the (same-length) lists are pairwise term equivalent
  - toString
```
public String toString()
```
    Reads the contents of this term (i.e., generates events) to a content handler
    
    Overrides:
    
    toString in class Object
    
    Parameters:
    
    contentHandler - the content handler that will receive the events describing the structure of this term
  - toEscapedString
```
public abstract String toEscapedString()
```
  - toString
```
public abstract String toString(OperatorsContext operatorsContext)
```
  - toEscapedString
```
public static <T extends Term> String toEscapedString(T... terms)
```
    Converts an array of Terms to its escaped String representation.
    
    Parameters:
    
    terms - an array of Terms to convert
    
    Returns:
    
    String representation of an array of Terms
  - toEscapedString
```
public static <T extends Term> String toEscapedString(List<T> terms)
```
    Converts a list of Terms to a String.
    
    Parameters:
    
    terms -
    
    Returns:
    
    String representation of a list of Terms
  - canUnify
```
public final boolean canUnify(Term term)
```
    Parameters:
    
    term - a compiled term
    
    Returns:
    
    true if this term can unify with the parameter term.
    
    Throws:
    
    UncompiledTermException - if this term or the receiver are not compiled and there are unbound variables.
  - compileAndUnifyVars
```
public final Map<String,Term> compileAndUnifyVars(Term term)
```
    Parameters:
    
    term - a term.
    
    Returns:
    
    a map of variables to terms according to the accomplished unification.
  - compileAndUnify
```
public final Term compileAndUnify(Term term)
```
    Parameters:
    
    term - a term.
    
    Returns:
    
    this term unified with the term sent as parameter.
  - unify
```
public void unify(Term term)
```
    Parameters:
    
    term -
    
    Throws:
    
    UncompiledTermException - if this term or the receiver are not compiled and there are unbound variables.
    
    NonUnifiableException - if this term is not unifiable with the receiver.
  - resolveBindings
```
public final Term resolveBindings()
```
    Returns:
    
    a term where the bindings of the variables of the receiver have been applied.
  - unifyAndBind
```
public final Term unifyAndBind(Term term)
```
    Parameters:
    
    term - a bindable term.
    
    Returns:
    
    this term unified with the term sent as parameter.
  - varBindings
```
public final Map<String,Term> varBindings()
```
    Returns:
    
    a map of variable names to their unified values.
  - compile
```
public final Term compile()
```
  - compile
```
public final Term compile(boolean preserveVarNames)
```
  - compile
```
public final Term compile(Environment env)
```
  - compile
```
public final Term compile(boolean preserveVarNames,
                          Environment env)
```
  - preCompile
```
public abstract Term preCompile(Environment env)
```
  - prepareForQuery
```
public final Term prepareForQuery()
```
  - prepareForQuery
```
public abstract Term prepareForQuery(Environment env)
```
  - prepareForFrame
```
public final Term prepareForFrame()
```
    Method only required for internal usage of the JPC Prolog engine. Every time a new clause is visited when backtracking, a new frame is created.
    
    Returns:
    
    a term to be used in a new frame.
  - prepareForFrame
```
public abstract Term prepareForFrame(Environment env)
```

Class Term

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Term

Method Detail

isHilog

arg

getArgs

arity

hasFunctor

hasFunctor

hasFunctor

hasFunctor

hasFunctor

isList

basicIsList

asList

listLength

isGround

replaceVariables

changeVariablesNames

hasVariable

getVariables

getVariableNames

getNonUnderscoreVariables

getNonUnderscoreVariableNames

getNamedVariables

getNamedVariablesNames

accept

termExpansion

read

read

basicRead

termEquals

termEquals

toString

toEscapedString

toString

toEscapedString

toEscapedString

canUnify

compileAndUnifyVars

compileAndUnify

unify

resolveBindings

unifyAndBind

varBindings

compile

compile

compile

compile

preCompile

prepareForQuery

prepareForQuery

prepareForFrame

prepareForFrame