jpl

Class Term

java.lang.Object

jpl.Term

Direct Known Subclasses:

Atom, Compound, Float_JPL, Integer_JPL, Long_JPL, String_JPL, Variable

public abstract class Term
extends Object

A Term is a base class for the many different kinds of Term (Atom, Variable, Compound, etc.). Programmers do not create instances of Term classes directly; rather, they should create instances of Term subclasses (Atom, Variable, Compound, etc.), which will inherit functionality from this class. 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: 1.1.1.1 $

Author:

Fred Dushin

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Term() This default constructor is provided in order for subclasses to be able to define their own default constructors.

Method Summary

Modifier and Type	Method and Description
protected abstract void	computeSubstitution(Hashtable bindings, Hashtable vars) This method computes a substitution from a Term.
protected static void	computeSubstitutions(Hashtable bindings, Hashtable vars, Term[] arg) Just calls computeSubstitution in each Term in the list.
abstract String	debugString()
static String	debugString(Term[] arg)
protected static Term[]	from_term_t(Hashtable vars, int n, term_t term0) This method calls from_term_t on each term in the consecutive list of term_ts.
protected static Term	from_term_t(Hashtable vars, term_t term) We do some type analysis on the term_t then forward the call to the appropriate class
protected abstract void	put(Hashtable var_table, term_t term) Cache the reference to the Prolog term_t here.
protected static boolean	terms_equals(Term[] t1, Term[] t2) This method is used 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).
protected static term_t	terms_to_term_ts(Hashtable var_table, Term[] arg) This static method converts an array of Terms to a *consecutive* sequence of term_t objects.
static String	toString(Term[] arg) Converts a list of Terms to a String.

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 is provided in order for subclasses to be able to define their own default constructors.

Method Detail

put

protected abstract void put(Hashtable var_table,
                            term_t term)

Cache the reference to the Prolog term_t here.

Parameters:

var_table - A Hashtable containing term_t's that are bound to (have been put in) Prolog variables as elements. The Elements are keyed by jpl.Variable instances. Cf. the put() implementation in the Variable class.

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.)

terms_to_term_ts

protected static term_t terms_to_term_ts(Hashtable var_table,
                                         Term[] arg)

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:

var_table - A Hashtable containing term_t's that are bound to (have be put in in) Prolog variables as elements. The Elements are keyed by jpl.Variable instances. Cf. the put() implementation in the Variable class.

arg - An array of jpl.Term references.

Returns:

consecutive term_t references (first of which is a structure)

from_term_t

protected static Term[] from_term_t(Hashtable vars,
                                    int n,
                                    term_t term0)

This method calls from_term_t on each term in the consecutive list of term_ts. A temporary jpl.term_t structure must be created in order to extract type information from the Prolog engine.

Parameters:

vars - A Hashtable containing jpl.Variable instances as elements, indexed by their *Prolog* names, which are guaranteed to be unique. Cf. the from_term_t method of the Variable class.

n - The number of consecutive term_ts

term0 - The 0th term_t (structure); subsequent term_ts are not structures.

Returns:

An array of converted Terms

from_term_t

protected static Term from_term_t(Hashtable vars,
                                  term_t term)

We do some type analysis on the term_t then forward the call to the appropriate class

Parameters:

vars - A Hashtable containing jpl.Variable instances as elements, indexed by their *Prolog* names, which are guaranteed to be unique. Cf. the from_term_t method of the Variable class.

term - The term_t to convert

Returns:

The converted class.

computeSubstitution

protected abstract void computeSubstitution(Hashtable bindings,
                                            Hashtable vars)

This method computes a substitution from a Term. The bindings Hashtable stores Terms, keyed by 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 Hashtable, 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:

bingings - table holding Term substitutions, keyed on Variables.

vars - A Hashtable holding the Variables that occur thus far in the term; keyed by internal (Prolog) string rep.

computeSubstitutions

protected static void computeSubstitutions(Hashtable bindings,
                                           Hashtable vars,
                                           Term[] arg)

Just calls computeSubstitution in each Term in the list.

Parameters:

table - table holding Term substitutions, keyed on Variables.

arg - a list of Terms

terms_equals

protected static boolean terms_equals(Term[] t1,
                                      Term[] t2)

This method is used 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 - an array of Terms

Returns:

true if all of the Terms in the arrays are pairwise equal

toString

public static String toString(Term[] arg)

Converts a list of Terms to a String.

Parameters:

arg - An aaray of Terms to convert

Returns:

String representation of a list of Terems

debugString

public abstract String debugString()

debugString

public static String debugString(Term[] arg)