Term

java.lang.Object
- org.jpl7.Term

Direct Known Subclasses:

Atom, Compound, Float, Integer, JRef, Variable
```
public abstract class Term
extends java.lang.Object
```
Term is the abstract base class for Compound, Atom, Variable, Integer and Float, which comprise a Java-oriented concrete syntax for Prolog. You cannot create instances of Term directly; rather, you should create instances of Term's concrete subclasses. Alternatively, use textToTerm() to construct a Term from its conventional Prolog source text representation.
Copyright (C) 2004 Paul Singleton
Copyright (C) 1998 Fred Dushin
This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library Public License for more details.

Version:

$Revision$

Author:

Fred Dushin

Constructor Summary

Constructors
Modifier Constructor and Description

protected Term()
This default constructor enables subclasses to define their own default constructors

Constructors
Modifier	Constructor and Description
`protected`	`Term()` This default constructor enables subclasses to define their own default constructors

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Term`	`arg(int i)` returns the i-th (1+) argument of a Term; defined only for Compound (and hence Atom); throws a JPLException for other Term subclasses
`Term[]`	`args()` returns, as a Term[], the arguments of a Compound returns an empty Term[] from an Atom, Integer or Float throws a JPLException from a Variable
`int`	`arity()` returns, as an int, the arity of a Compound, Atom, Integer or Float; throws a JPLException from a Variable
`java.lang.String`	`atomType()`
`java.math.BigInteger`	`bigValue()` returns the value (as a java.math.BigInteger) of an Integer; throws a JPLException from a Compound, Atom, Float or Variable
`double`	`doubleValue()` returns the value (as a double) of an Integer or Float throws a JPLException from any other subclass
`float`	`floatValue()` returns the value (as a float) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
`protected void`	`getSubst(java.util.Map<java.lang.String,Term> varnames_to_Terms, java.util.Map<term_t,Variable> vars_to_Vars)` This method computes a substitution from a Term.
`protected static void`	`getSubsts(java.util.Map<java.lang.String,Term> varnames_to_Terms, java.util.Map<term_t,Variable> vars_to_Vars, Term[] args)` Just calls computeSubstitution for each Term in the array.
`protected static Term`	`getTerm(java.util.Map<term_t,Variable> vars_to_Vars, term_t term)` create and return a org.jpl7.Term representation of the given Prolog term
`protected static Term`	`getTerm(term_t term)`
`boolean`	`hasFunctor(double value, int arity)` Tests whether this Term's functor has (double) 'name' and 'arity' Returns false if called inappropriately
`boolean`	`hasFunctor(int value, int arity)` Tests whether this Term's functor has (int) 'name' and 'arity' Returns false if called inappropriately
`boolean`	`hasFunctor(java.lang.String name, int arity)` Tests whether this Term's functor has (String) 'name' and 'arity' Returns false if called inappropriately
`int`	`intValue()` returns the value (as an int) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
`boolean`	`isAtom()` whether this Term is an Atom (of some kind)
`boolean`	`isBigInteger()` whether this Term is an Integer whose value is too big to represent as a long
`boolean`	`isCompound()` whether this Term represents a compound term
`boolean`	`isFloat()` whether this Term represents a float
`boolean`	`isInteger()` whether this Term represents an integer
`boolean`	`isJFalse()` whether this Term is a 'jfalse' structure, i.e.
`boolean`	`isJNull()` whether this Term is a 'jnull' structure, i.e.
`boolean`	`isJObject()` whether this Term is a 'jobject' structure, i.e.
`boolean`	`isJRef()` whether this Term is a 'jref' structure, i.e.
`boolean`	`isJTrue()` whether this Term is a 'jtrue' structure, i.e.
`boolean`	`isJVoid()` whether this Term is a 'jvoid' structure, i.e.
`boolean`	`isListNil()` whether this Term denotes (syntax-specifically) an empty list
`boolean`	`isListPair()` whether this Term denotes (syntax-specifically) a list pair
`boolean`	`isVariable()` whether this Term is a variable
`java.lang.Object`	`jrefToObject()`
`int`	`listLength()` the length of this list, iff it is one, else an exception is thrown
`long`	`longValue()` returns the value (as a long) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
`java.lang.String`	`name()` returns, as a String, the name of a Compound, Atom or Variable throws a JPLException from an Integer or Float
`static Term`	`objectToJRef(java.lang.Object obj)` returns a new Term instance which represents the given object
`protected abstract void`	`put(java.util.Map<java.lang.String,term_t> varnames_to_vars, term_t term)` Cache the reference to the Prolog term_t here.
`protected void`	`put(term_t term)`
`protected Term`	`putParams(Term plist)`
`Term`	`putParams(Term[] ps)`
`protected Term`	`putParams1(IntHolder next, Term[] ps)`
`protected static Term[]`	`putParams2(Term[] ts, IntHolder next, Term[] ps)`
`static void`	`putTerm(java.lang.Object obj, term_t termref)`
`protected static term_t`	`putTerms(java.util.Map<java.lang.String,term_t> varnames_to_vars, Term[] args)` This static method converts an array of Terms to a consecutive sequence of term_t objects.
`protected static boolean`	`terms_equals(Term[] t1, Term[] t2)` This method is used (by Compound.equals) to determine the Terms in two Term arrays are pairwise equal, where two Terms are equal if they satisfy the equals predicate (defined differently in each Term subclass).
`static java.lang.String`	`toString(Term[] args)` Converts a list of Terms to a String.
`Term[]`	`toTermArray()` returns an array of terms which are the successive members of this list, if it is a list, else throws an exception
`abstract int`	`type()` returns the type of this term, as one of org.jpl7.fli.Prolog.COMPOUND, .ATOM, .VARIABLE, .INTEGER, .FLOAT etc
`abstract java.lang.String`	`typeName()` returns the name of the type of this term, as one of "Compound", "Atom", "Variable", "Integer", "Float" etc

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

- Constructor Detail
  - Term
```
protected Term()
```
    This default constructor enables subclasses to define their own default constructors
- Method Detail
  - arg
```
public Term arg(int i)
```
    returns the i-th (1+) argument of a Term; defined only for Compound (and hence Atom); throws a JPLException for other Term subclasses
    
    Returns:
    
    the i-th argument of a (Compound) Term
  - args
```
public Term[] args()
```
    returns, as a Term[], the arguments of a Compound returns an empty Term[] from an Atom, Integer or Float throws a JPLException from a Variable
    
    Returns:
    
    the arguments of a Compound as a Term[
  - atomType
```
public java.lang.String atomType()
```
  - hasFunctor
```
public boolean hasFunctor(java.lang.String name,
                          int arity)
```
    Tests whether this Term's functor has (String) 'name' and 'arity' Returns false if called inappropriately
    
    Returns:
    
    whether this Term's functor has (String) 'name' and 'arity'
  - hasFunctor
```
public boolean hasFunctor(int value,
                          int arity)
```
    Tests whether this Term's functor has (int) 'name' and 'arity' Returns false if called inappropriately
    
    Returns:
    
    whether this Term's functor has (int) 'name' and 'arity'
  - hasFunctor
```
public boolean hasFunctor(double value,
                          int arity)
```
    Tests whether this Term's functor has (double) 'name' and 'arity' Returns false if called inappropriately
    
    Returns:
    
    whether this Term's functor has (double) 'name' and 'arity'
  - name
```
public java.lang.String name()
```
    returns, as a String, the name of a Compound, Atom or Variable throws a JPLException from an Integer or Float
    
    Returns:
    
    the name of a Compound, Atom or Variable
  - arity
```
public int arity()
```
    returns, as an int, the arity of a Compound, Atom, Integer or Float; throws a JPLException from a Variable
    
    Returns:
    
    the arity of a Compound, Atom, Integer or Float
  - intValue
```
public int intValue()
```
    returns the value (as an int) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
    
    Returns:
    
    the value (as an int) of an Integer or Float
  - longValue
```
public long longValue()
```
    returns the value (as a long) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
    
    Returns:
    
    the value (as a long) of an Integer or Float
  - floatValue
```
public float floatValue()
```
    returns the value (as a float) of an Integer or Float throws a JPLException from a Compound, Atom or Variable
    
    Returns:
    
    the value (as a float) of an Integer or Float
  - bigValue
```
public java.math.BigInteger bigValue()
```
    returns the value (as a java.math.BigInteger) of an Integer; throws a JPLException from a Compound, Atom, Float or Variable
    
    Returns:
    
    the value (as a java.math.BigInteger) of an Integer; throws a JPLException from a Compound, Atom, Float or Variable
  - doubleValue
```
public double doubleValue()
```
    returns the value (as a double) of an Integer or Float throws a JPLException from any other subclass
    
    Returns:
    
    the value (as an double) of an Integer or Float
  - type
```
public abstract int type()
```
    returns the type of this term, as one of org.jpl7.fli.Prolog.COMPOUND, .ATOM, .VARIABLE, .INTEGER, .FLOAT etc
    
    Returns:
    
    the type of this term, as one of org.jpl7.fli.Prolog.COMPOUND, .ATOM, .VARIABLE, .INTEGER, .FLOAT etc
  - typeName
```
public abstract java.lang.String typeName()
```
    returns the name of the type of this term, as one of "Compound", "Atom", "Variable", "Integer", "Float" etc
    
    Returns:
    
    the name of the type of this term, as one of "Compound", "Atom", "Variable", "Integer", "Float" etc
  - isAtom
```
public boolean isAtom()
```
    whether this Term is an Atom (of some kind)
    
    Returns:
    
    whether this Term is an Atom (of some kind)
  - isBigInteger
```
public boolean isBigInteger()
```
    whether this Term is an Integer whose value is too big to represent as a long
    
    Returns:
    
    whether this Term is an Integer whose value is too big to represent as a long
  - isCompound
```
public boolean isCompound()
```
    whether this Term represents a compound term
    
    Returns:
    
    whether this Term represents a compound atom
  - isFloat
```
public boolean isFloat()
```
    whether this Term represents a float
    
    Returns:
    
    whether this Term represents a float
  - isInteger
```
public boolean isInteger()
```
    whether this Term represents an integer
    
    Returns:
    
    whether this Term represents an integer
  - isVariable
```
public boolean isVariable()
```
    whether this Term is a variable
    
    Returns:
    
    whether this Term is a variable
  - isListNil
```
public boolean isListNil()
```
    whether this Term denotes (syntax-specifically) an empty list
    
    Returns:
    
    whether this Term denotes (syntax-specifically) an empty list
  - isListPair
```
public boolean isListPair()
```
    whether this Term denotes (syntax-specifically) a list pair
    
    Returns:
    
    whether this Term denotes (syntax-specifically) a list pair
  - isJFalse
```
public boolean isJFalse()
```
    whether this Term is a 'jfalse' structure, i.e. @(false)
    
    Returns:
    
    whether this Term is a 'jfalse' structure, i.e. @(false)
  - isJNull
```
public boolean isJNull()
```
    whether this Term is a 'jnull' structure, i.e. @(null)
    
    Returns:
    
    whether this Term is a 'jnull' structure, i.e. @(null)
  - isJObject
```
public boolean isJObject()
```
    whether this Term is a 'jobject' structure, i.e. @(Tag)
    
    Returns:
    
    whether this Term is a 'jobject' structure, i.e. @(Tag)
  - isJRef
```
public boolean isJRef()
```
    whether this Term is a 'jref' structure, i.e. @(Tag) or @(null)
    
    Returns:
    
    whether this Term is a 'jref' structure, i.e. @(Tag) or @(null)
  - isJTrue
```
public boolean isJTrue()
```
    whether this Term is a 'jtrue' structure, i.e. @(true)
    
    Returns:
    
    whether this Term is a 'jtrue' structure, i.e. @(true)
  - isJVoid
```
public boolean isJVoid()
```
    whether this Term is a 'jvoid' structure, i.e. @(void)
    
    Returns:
    
    whether this Term is a 'jvoid' structure, i.e. @(void)
  - jrefToObject
```
public java.lang.Object jrefToObject()
```
  - objectToJRef
```
public static Term objectToJRef(java.lang.Object obj)
```
    returns a new Term instance which represents the given object
  - putParams
```
public Term putParams(Term[] ps)
```
  - putParams
```
protected Term putParams(Term plist)
```
  - putParams1
```
protected Term putParams1(IntHolder next,
                          Term[] ps)
```
  - putParams2
```
protected static Term[] putParams2(Term[] ts,
                                   IntHolder next,
                                   Term[] ps)
```
  - 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:
    
    JPLException
  - toTermArray
```
public Term[] toTermArray()
```
    returns an array of terms which are the successive members of this list, if it is a list, else throws an exception
    
    Returns:
    
    an array of terms which are the successive members of this list, if it is a list
    
    Throws:
    
    JPLException
  - put
```
protected void put(term_t term)
```
  - put
```
protected abstract void put(java.util.Map<java.lang.String,term_t> varnames_to_vars,
                            term_t term)
```
    Cache the reference to the Prolog term_t here.
    
    Parameters:
    
    varnames_to_vars - A Map from variable names to JPL Variables.
    
    term - A (previously created) term_t which is to be put with a Prolog term-type appropriate to the Term type (e.g., Atom, Variable, Compound, etc.) on which the method is invoked.)
  - putTerms
```
protected static term_t putTerms(java.util.Map<java.lang.String,term_t> varnames_to_vars,
                                 Term[] args)
```
    This static method converts an array of Terms to a *consecutive* sequence of term_t objects. Note that the first term_t object returned is a term_t class (structure); the succeeding term_t objects are consecutive references obtained by incrementing the *value* field of the term_t.
    
    Parameters:
    
    varnames_to_vars - Map from variable names to JPL Variables.
    
    args - An array of org.jpl7.Term references.
    
    Returns:
    
    consecutive term_t references (first of which is a structure)
  - putTerm
```
public static void putTerm(java.lang.Object obj,
                           term_t termref)
```
  - getTerm
```
protected static Term getTerm(java.util.Map<term_t,Variable> vars_to_Vars,
                              term_t term)
```
    create and return a org.jpl7.Term representation of the given Prolog term
    
    Parameters:
    
    vars_to_Vars - A Map from Prolog variables to org.jpl7.Variable instances
    
    term - The Prolog term (in a term_t holder) to convert
    
    Returns:
    
    The converted Term subclass instance.
  - getTerm
```
protected static Term getTerm(term_t term)
```
  - getSubst
```
protected void getSubst(java.util.Map<java.lang.String,Term> varnames_to_Terms,
                        java.util.Map<term_t,Variable> vars_to_Vars)
```
    This method computes a substitution from a Term. The bindings Map stores Terms, keyed by names of Variables. Thus, a substitution is as it is in mathematical logic, a sequence of the form \sigma = {t_0/x_0, ..., t_n/x_n}. Once the substitution is computed, the substitution should satisfy \sigma T = t where T is the Term from which the substitution is computed, and t is the term_t which results from the Prolog query.
    A second Map, vars, is required; this table holds the Variables that occur (thus far) in the unified term. The Variable instances in this table are guaranteed to be unique and are keyed on Strings which are Prolog internal representations of the variables.
    
    Parameters:
    
    bindings - table holding Term substitutions, keyed on names of Variables.
    
    vars - A Map holding the Variables that occur thus far in the term; keyed by internal (Prolog) string rep.
  - getSubsts
```
protected static void getSubsts(java.util.Map<java.lang.String,Term> varnames_to_Terms,
                                java.util.Map<term_t,Variable> vars_to_Vars,
                                Term[] args)
```
    Just calls computeSubstitution for each Term in the array.
    
    Parameters:
    
    varnames_to_Terms - a Map from variable names to Terms
    
    vars_to_Vars - a Map from Prolog variables to JPL Variables
    
    args - an array of Terms
  - terms_equals
```
protected static boolean terms_equals(Term[] t1,
                                      Term[] t2)
```
    This method is used (by Compound.equals) to determine the Terms in two Term arrays are pairwise equal, where two Terms are equal if they satisfy the equals predicate (defined differently in each Term subclass).
    
    Parameters:
    
    t1 - an array of Terms
    
    t2 - another array of Terms
    
    Returns:
    
    true if all of the Terms in the (same-length) arrays are pairwise equal
  - toString
```
public static java.lang.String toString(Term[] args)
```
    Converts a list of Terms to a String.
    
    Parameters:
    
    args - An array of Terms to convert
    
    Returns:
    
    String representation of a list of Terms

Class Term

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Term

Method Detail

arg

args

atomType

hasFunctor

hasFunctor

hasFunctor

name

arity

intValue

longValue

floatValue

bigValue

doubleValue

type

typeName

isAtom

isBigInteger

isCompound

isFloat

isInteger

isVariable

isListNil

isListPair

isJFalse

isJNull

isJObject

isJRef

isJTrue

isJVoid

jrefToObject

objectToJRef

putParams

putParams

putParams1

putParams2

listLength

toTermArray

put

put

putTerms

putTerm

getTerm

getTerm

getSubst

getSubsts

terms_equals

toString