// FILE. . . . . d:/hak/hlt/src/hlt/fot/FirstOrderTermStructure.java
// EDIT BY . . . Hassan Ait-Kaci
// ON MACHINE. . Hak-Laptop
// STARTED ON. . Sat Jul 14 07:23:42 2018
package hlt.fot;
/**
* This is a class for first-order terms defined on a signature of Functors. It is of the form
* f(t1, ..., tf.arity()), where
* f is a functor and each ti is a FirstOrderTerm, for 0
* ≤ i ≤ f.arity().
*
* @see FirstOrderTerm
* @see Functor
*
* @version Last modified on Fri Aug 24 04:31:21 2018 by hak
* @author Hassan Aït-Kaci
* @copyright © by the author
*/
public class FirstOrderTermStructure implements FirstOrderTerm
{
/* ************************************************************************ */
/**
* This term's functor.
*/
protected Functor functor;
/**
* Returns this term's functor.
*/
public Functor functor ()
{
return functor;
}
/**
* This term's arguments, or null for constants (functors of
* arity 0).
*/
protected FirstOrderTerm[] arguments;
/**
* Returns this term's arguments or null when the functor's
* arity is 0.
*/
public FirstOrderTerm[] arguments ()
{
return arguments;
}
/* ************************************************************************ */
// Constructors:
// This one is never used; but if not defined, the compiler complains!
protected FirstOrderTermStructure ()
{
}
public FirstOrderTermStructure (Functor functor)
{
this.functor = functor;
}
public FirstOrderTermStructure (Functor functor, FirstOrderTerm[] arguments)
{
this.functor = functor;
this.arguments = arguments;
}
/* ************************************************************************ */
/**
* Returns the term's argument at argument position or
* null when the functor's arity is 0. N.B.:
* argument counting goes from 1 to functor.arity().
*/
public FirstOrderTerm argument (int position)
{
// System.err.println("&&& argument position "+position+" out of "+arguments.length);
return arguments == null ? null : arguments[position-1];
}
/**
* Sets the term's argument at position to the specified
* term. N.B.: argument counting goes from 1 to
* functor.arity().
*/
public void setArgument (int position, FirstOrderTerm term)
{
arguments[position-1] = term;
}
/* ************************************************************************ */
/**
* Returns false. This implements the FirstOrderTerm
* interface's method identifying this as a non-variable
* term; i.e., a term structure (a constant or one with arguments).
*/
final public boolean isVariable ()
{
return false;
}
/**
* This returns true iff this is a constant (i.e., it has no arguments).
*/
final public boolean isConstant ()
{
// System.err.println("&&& is functor "+functor+"/"+functor.arity()+
// " a constant?"+(functor.arity() == 0?" yes!":" no!"));
return functor.arity() == 0;
}
/* ************************************************************************ */
// DEREFERENCED FORM
/* ************************************************************************ */
/**
* Returns a term that is equal to this term after having dereferenced
* all its contents.
*/
public FirstOrderTerm deref ()
{
if (isConstant())
return this;
FirstOrderTerm[] derefArguments = new FirstOrderTerm[arguments.length];
for (int i = 0; i < arguments.length; i++)
derefArguments[i] = arguments[i].deref();
return new FirstOrderTermStructure(functor,derefArguments);
}
/* ************************************************************************ */
// STRING FORM
/* ************************************************************************ */
/**
* A cache to prevent useless recomputations of the same string.
*/
private String stringForm;
/**
* Returns a string form of this term structure not taking into
* account the bindings of its variables.
*/
public String toString ()
{
if (stringForm != null)
return stringForm;
StringBuffer buffer = new StringBuffer(functor.name());
if (!isConstant())
{
// System.err.println("&&& arguments = "+arguments);
buffer.append("(");
for (int i=1; i <= functor.arity(); i++)
buffer.append(argument(i).toString()+(i==functor.arity()?")":","));
}
return stringForm = buffer.toString();
}
/**
* Returns a string form of this term structure taking into account
* the bindings of its variables. Overrrides the equivalent but less
* efficient default in FirstOrderTerm. N.B.: no
* caching for this one as it may change if some variable bindings do.
*/
public String derefToString ()
{
StringBuffer buffer = new StringBuffer(functor.name());
if (functor.arity() != 0)
{
buffer.append("(");
for (int i=1; i <= functor.arity(); i++)
buffer.append(argument(i).derefToString()+(i==functor.arity()?")":","));
}
return buffer.toString();
}
/* ************************************************************************ */
// EQUALITY
/* ************************************************************************ */
/**
* Returns true is this term structure is equal symbol for
* symbol to the given one (although they may be different
* individuals).
*/
public boolean equal (FirstOrderTerm term)
{
if (this == term)
return true;
if (term.isVariable())
return false;
FirstOrderTermStructure T = (FirstOrderTermStructure)term;
boolean isEqual = functor.equal(T.functor());
int i = 0;
while (isEqual && ++i <= functor.arity())
isEqual &= argument(i).equal(T.argument(i));
return isEqual;
}
}