Compound (JPC 0.0.1-alpha-SNAPSHOT API)

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

```
public final class Compound
extends Term
```
A class reifying a logic compound term

Author:

scastro

Constructor Summary

Constructors
Constructor and Description
`Compound(String name, List<? extends Term> args)`
`Compound(Term name, List<? extends Term> args)` Creates a Compound with id and args.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(TermVisitor termVisitor)` Accepts a Jpc term visitor.
`ListTerm`	`asList()` Returns a list representation of this term.
`protected boolean`	`basicIsList()`
`protected void`	`basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)`
`boolean`	`equals(Object obj)` Two Compounds are equal if they are identical (same object) or their names and arities are equal and their respective arguments are equal.
`List<Term>`	`getArgs()` Returns the arguments of this Compound (1..arity) of this Compound as a List of Term.
`Functor`	`getFunctor()`
`Term`	`getName()` Returns the id of this Compound.
`String`	`getNameString()`
`boolean`	`hasFunctor(Functor functor)` Whether this term has a given functor.
`int`	`hashCode()`
`boolean`	`hasName(String name)`
`boolean`	`hasName(Term term)`
`boolean`	`isCons()`
`boolean`	`isGround()`
`boolean`	`isHilog()`
`Term`	`preCompile(Environment env)`
`Term`	`prepareForFrame(Environment env)`
`Term`	`prepareForQuery(Environment env)`
`boolean`	`termEquals(Term term)` 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.
`String`	`toEscapedString()` Returns a prefix functional representation of a Compound of the form id(arg1,...),
`String`	`toString(OperatorsContext operatorsContext)`
`void`	`unify(Term term)`
`boolean`	`usesOperator(Operator operator)`

Methods inherited from class org.jpc.term.Term
arg, arity, canUnify, changeVariablesNames, compile, compile, compile, compile, compileAndUnify, compileAndUnifyVars, getNamedVariables, getNamedVariablesNames, getNonUnderscoreVariableNames, getNonUnderscoreVariables, getVariableNames, getVariables, hasFunctor, hasFunctor, hasFunctor, hasFunctor, hasVariable, isList, listLength, prepareForFrame, prepareForQuery, read, read, replaceVariables, resolveBindings, termEquals, termExpansion, toEscapedString, toEscapedString, toString, unifyAndBind, varBindings

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

- Constructor Detail
  - Compound
```
public Compound(String name,
                List<? extends Term> args)
```
  - Compound
```
public Compound(Term name,
                List<? extends Term> args)
```
    Creates a Compound with id and args.
    
    Parameters:
    
    id - the id of this Compound
    
    args - the (one or more) arguments of this Compound
- Method Detail
  - isHilog
```
public boolean isHilog()
```
    Overrides:
    
    isHilog in class Term
    
    Returns:
    
    true if the term is a proper Hilog term (i.e., a Hilog term that is not a Prolog term)
  - basicIsList
```
protected boolean basicIsList()
```
    Overrides:
    
    basicIsList in class Term
  - isCons
```
public boolean isCons()
```
  - asList
```
public ListTerm asList()
```
    Description copied from class: Term
    
    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)
    
    Overrides:
    
    asList in class Term
    
    Returns:
    
    a list representation of this term.
  - hasName
```
public boolean hasName(String name)
```
  - hasName
```
public boolean hasName(Term term)
```
  - hasFunctor
```
public boolean hasFunctor(Functor functor)
```
    Description copied from class: Term
    
    Whether this term has a given functor.
    
    Specified by:
    
    hasFunctor in class Term
    
    Parameters:
    
    functor - the functor of this term.
    
    Returns:
    
    true if the term has the given functor. False otherwise.
  - getFunctor
```
public Functor getFunctor()
```
  - getName
```
public Term getName()
```
    Returns the id of this Compound.
    
    Returns:
    
    the id of this Compound
  - getNameString
```
public String getNameString()
```
  - getArgs
```
public List<Term> getArgs()
```
    Returns the arguments of this Compound (1..arity) of this Compound as a List of Term.
    
    Overrides:
    
    getArgs in class Term
    
    Returns:
    
    the arguments of this Compound (1..arity) of this Compound as a List of Term.
  - isGround
```
public boolean isGround()
```
    Specified by:
    
    isGround in class Term
    
    Returns:
    
    true if the term is ground (it does not have unbound variables). false otherwise.
  - accept
```
public void accept(TermVisitor termVisitor)
```
    Description copied from class: Term
    
    Accepts a Jpc term visitor.
    
    Specified by:
    
    accept in class Term
    
    Parameters:
    
    termVisitor - the accepted visitor
  - usesOperator
```
public boolean usesOperator(Operator operator)
```
  - basicRead
```
protected void basicRead(TermContentHandler contentHandler,
                         com.google.common.base.Function<Term,Term> termExpander)
```
    Specified by:
    
    basicRead in class Term
  - toString
```
public String toString(OperatorsContext operatorsContext)
```
    Specified by:
    
    toString in class Term
  - toEscapedString
```
public String toEscapedString()
```
    Returns a prefix functional representation of a Compound of the form id(arg1,...),
    
    Specified by:
    
    toEscapedString in class Term
    
    Returns:
    
    string representation of an Compound
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Two Compounds are equal if they are identical (same object) or their names and arities are equal and their respective arguments are equal.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - the Object to compare (not necessarily another Compound)
    
    Returns:
    
    true if the Object satisfies the above condition
  - termEquals
```
public boolean termEquals(Term term)
```
    Description copied from class: Term
    
    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
    
    Overrides:
    
    termEquals in class Term
    
    Returns:
  - unify
```
public void unify(Term term)
```
    Overrides:
    
    unify in class Term
  - preCompile
```
public Term preCompile(Environment env)
```
    Specified by:
    
    preCompile in class Term
  - prepareForQuery
```
public Term prepareForQuery(Environment env)
```
    Specified by:
    
    prepareForQuery in class Term
  - prepareForFrame
```
public Term prepareForFrame(Environment env)
```
    Specified by:
    
    prepareForFrame in class Term

Class Compound

Constructor Summary

Method Summary

Methods inherited from class org.jpc.term.Term

Methods inherited from class java.lang.Object

Constructor Detail

Compound

Compound

Method Detail

isHilog

basicIsList

isCons

asList

hasName

hasName

hasFunctor

getFunctor

getName

getNameString

getArgs

isGround

accept

usesOperator

basicRead

toString

toEscapedString

hashCode

equals

termEquals

unify

preCompile

prepareForQuery

prepareForFrame