jpl

Class Compound

java.lang.Object

jpl.Term

jpl.Compound

Direct Known Subclasses:

List, Tuple

public class Compound
extends Term

A Compound is a base class for all of the compound class types (e.g., List, Tuple, etc.), but it can also be instantiated to produce, for example, any functional expression. For example, to produce the term f(a), one might write:

 Term[] arg = { new Atom( "a" ) };
 Compound f = new Compound( new Atom( "f" ), arg );
 

See the List and Tuple classes for common extensions of 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

See Also:

Term, List, Tuple

Field Summary

Fields

Modifier and Type	Field and Description
protected Term[]	args_ the arguments in this Compound
protected Atom	atom_ the atom in this Compound

Constructor Summary

Constructors

Constructor and Description
Compound(Atom atom, Term[] args) Creates a Comound with an Atom and an array of arguments.
Compound(String name, Term t0) This constructor is shorthand for
Compound(String name, Term[] args) This constructor is short for
Compound(String name, Term t0, Term t1) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4, Term t5) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4, Term t5, Term t6) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4, Term t5, Term t6, Term t7) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4, Term t5, Term t6, Term t7, Term t8) This constructor is shorthand for
Compound(String name, Term t0, Term t1, Term t2, Term t3, Term t4, Term t5, Term t6, Term t7, Term t8, Term t9) This constructor is shorthand for

Method Summary

Modifier and Type	Method and Description
Term[]	args()
Atom	atom()
protected void	computeSubstitution(Hashtable bindings, Hashtable vars) Nothing needs to be done except to pass the buck to the args.
String	debugString()
boolean	equals(Object obj) Two Compounds are equal if their atoms are equal and their term arguments are equal.
protected static Term	from_term_t(Hashtable vars, term_t term) Converts a term_t to a Compound.
Term	ith(int i)
protected void	put(Hashtable var_table, term_t term) To put an Compound in a term, we create a sequence of term_t references from the Term terms_to_term_t method, and then use the Prolog cons_functor_v method to create a Prolog compound.
String	toString() Converts a Compound to its String form, atom( arg_1, ..., arg_n )

Methods inherited from class jpl.Term

computeSubstitutions, debugString, from_term_t, terms_equals, terms_to_term_ts, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

atom_

protected Atom atom_

the atom in this Compound

args_

protected Term[] args_

the arguments in this Compound

Constructor Detail

Compound

public Compound(Atom atom,
                Term[] args)

Creates a Comound with an Atom and an array of arguments. The length of the array determines the arity of the Compound.

Parameters:

atom - the Atom in this Compound

args - the arguments in this Compound

Compound

public Compound(String name,
                Term[] args)

This constructor is short for

 new Compound( new Atom( name ), arg )
 

Parameters:

name - the name for the Atom in this Compound

args - the arguments in this Compound

Compound

public Compound(String name,
                Term t0)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4,
                Term t5)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4, 
                       t5 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

t5 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4,
                Term t5,
                Term t6)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4, 
                       t5, t6 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

t5 - a jpl.Term

t6 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4,
                Term t5,
                Term t6,
                Term t7)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4, 
                       t5, t6, t7 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

t5 - a jpl.Term

t6 - a jpl.Term

t7 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4,
                Term t5,
                Term t6,
                Term t7,
                Term t8)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4, 
                       t5, t6, t7, t8 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

t5 - a jpl.Term

t6 - a jpl.Term

t7 - a jpl.Term

t8 - a jpl.Term

Compound

public Compound(String name,
                Term t0,
                Term t1,
                Term t2,
                Term t3,
                Term t4,
                Term t5,
                Term t6,
                Term t7,
                Term t8,
                Term t9)

This constructor is shorthand for

 new Compound( 
     new Atom( name ), 
     Util.toTermArray( t0, t1, t2, t3, t4, 
                       t5, t6, t7, t8, t9 ) )
 

Parameters:

name - the name of the functor in this Compound

t0 - a jpl.Term

t1 - a jpl.Term

t2 - a jpl.Term

t3 - a jpl.Term

t4 - a jpl.Term

t5 - a jpl.Term

t6 - a jpl.Term

t7 - a jpl.Term

t8 - a jpl.Term

t9 - a jpl.Term

Method Detail

atom

public final Atom atom()

Returns:

the atom in this Compound

args

public final Term[] args()

Returns:

the arguments in this Compound

ith

public final Term ith(int i)

Returns:

the ith argument in this Compound

put

protected final void put(Hashtable var_table,
                         term_t term)

To put an Compound in a term, we create a sequence of term_t references from the Term terms_to_term_t method, and then use the Prolog cons_functor_v method to create a Prolog compound.

Specified by:

put in class Term

Parameters:

var_table - A Hashtable containing term_t's that are bound to (have packed 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 packed with a Prolog term-type appropriate to the Term type (e.g., Atom, Variable, Compound, etc.) on which the method is invoked.)

from_term_t

protected static Term from_term_t(Hashtable vars,
                                  term_t term)

Converts a term_t to a Compound. In this case, we create an Atom and a list of Terms by calling from_term_t for each term_t reference we get from Prolog.get_arg (Not sure why we couldn't get a sequence from there, but...).

We have to do a bit of type analysis to create Java objects of the right type. For example, we don't want to create just a Compound if the term_t is a list or a tuple; we want to create a List or a Tuple, accordingly.

Parameters:

term - The term_t to convert

Returns:

A new Atom

computeSubstitution

protected final void computeSubstitution(Hashtable bindings,
                                         Hashtable vars)

Nothing needs to be done except to pass the buck to the args.

Specified by:

computeSubstitution in class Term

Parameters:

table - table holding Term substitutions, keyed on Variables.

toString

public String toString()

Converts a Compound to its String form, atom( arg_1, ..., arg_n )

Overrides:

toString in class Object

Returns:

string representation of an Compound

debugString

public String debugString()

Specified by:

debugString in class Term

equals

public final boolean equals(Object obj)

Two Compounds are equal if their atoms are equal and their term arguments are equal.

Overrides:

equals in class Object

Parameters:

obj - the Object to compare

Returns:

true if the Object satisfies the above condition