Compound.java

Go to the documentation of this file.

//tabstop=4
//*****************************************************************************/
// Project: jpl
//
// File:    $Id$
// Date:    $Date$
// Author:  Fred Dushin <fadushin@syr.edu>
//          
//
// Description:
//    
//
// -------------------------------------------------------------------------
// Copyright (c) 2004 Paul Singleton
// Copyright (c) 1998 Fred Dushin
//                    All rights reserved.
// 
// 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.
//*****************************************************************************/
package jpl;

import java.util.Map;

import jpl.fli.IntHolder;
import jpl.fli.Prolog;
import jpl.fli.StringHolder;
import jpl.fli.term_t;

//----------------------------------------------------------------------/
// Compound
public class Compound extends Term {
        //==================================================================/
        //  Attributes
        //==================================================================/
        protected final String name;
        protected final Term[] args;
        //==================================================================/
        //  Constructors
        //==================================================================/
        protected Compound(String name) {
                if (name == null) {
                        throw new JPLException("jpl.Atom: cannot construct with null name");
                }
                this.name = name;
                this.args = new Term[] {};
        }
        public Compound(String name, Term[] args) {
                if (name == null) {
                        throw new JPLException("jpl.Compound: cannot construct with null name");
                }
                if (args == null) {
                        throw new JPLException("jpl.Compound: cannot construct with null args");
                }
                if (args.length == 0) {
                        throw new JPLException("jpl.Compound: cannot construct with zero args");
                }
                this.name = name;
                this.args = args;
        }
        public Compound(String name, int arity) {
                if (name == null) {
                        throw new JPLException("jpl.Compound: cannot construct with null name");
                }
                if (arity < 0) {
                        throw new JPLException("jpl.Compound: cannot construct with negative arity");
                }
                this.name = name;
                this.args = new Term[arity];
        }
        //==================================================================/
        //  Methods (common)
        //==================================================================/
        public final Term arg(int i) {
                return args[i - 1];
        }
        public final boolean hasFunctor(String name, int arity) {
                return name.equals(this.name) && arity == args.length; // BUGFIX: was just name.equals(name)
        }
        public boolean isJFalse() {
                return hasFunctor("@", 1) && arg(1).hasFunctor("false", 0);
        }
        public boolean isJTrue() {
                return hasFunctor("@", 1) && arg(1).hasFunctor("true", 0);
        }
        public boolean isJNull() {
                return hasFunctor("@", 1) && arg(1).hasFunctor("null", 0);
        }
        public boolean isJVoid() {
                return hasFunctor("@", 1) && arg(1).hasFunctor("void", 0);
        }
        public boolean isJObject() {
                return hasFunctor("@", 1) && arg(1).isAtom() && JPL.isTag(arg(1).name());
        }
        public boolean isJRef() {
                return isJObject() || isJNull();
        }
        public Object jrefToObject() {
                if (this.isJObject()) {
                        return Prolog.tag_to_object(arg(1).name());
                } else if (this.isJNull()) {
                        return null;
                } else {
                        throw new JPLException("Term.jrefToObject: term is not a JRef");
                }
        }
        public final String name() {
                return name;
        }
        public final int arity() {
                return args.length;
        }
        public String toString() {
                return quotedName() + (args.length > 0 ? "(" + Term.toString(args) + ")" : "");
        }
        public final boolean equals(Object obj) {
                return (this == obj || (obj instanceof Compound && name.equals(((Compound) obj).name) && Term.terms_equals(args, ((Compound) obj).args)));
        }
        public int type() {
                return Prolog.COMPOUND;
        }
        public String typeName(){
                return "Compound";
        }
        public void setArg(int i, Term arg) {
                if (i <= 0) {
                        throw new JPLException("jpl.Compound#setArg: bad (non-positive) argument index");
                }
                if (i > args.length) {
                        throw new JPLException("jpl.Compound#setArg: bad (out-of-range) argument index");
                }
                if (arg == null) {
                        throw new JPLException("jpl.Compound#setArg: bad (null) argument");
                }
                args[i - 1] = arg;
        }
        //==================================================================/
        //  Methods (protected)
        //==================================================================/
        protected String quotedName() {
                return ((Atom) (new Query(new Compound("sformat", new Term[] { new Variable("S"), new Atom("~q"), new Compound(".", new Term[] { new Atom(this.name), new Atom("[]") }) }))).oneSolution().get(
                        "S")).name;
        }
        //==================================================================/
        //  Methods (deprecated)
        //==================================================================/
        public final Term[] args() {
                return args;
        }
        public final Term arg0(int i) {
                return args[i];
        }
        public String debugString() {
                return "(Compound " + name + " " + Term.debugString(args) + ")";
        }
        //==================================================================/
        //  Converting JPL Terms to Prolog terms
        //==================================================================/
        protected final void put(Map varnames_to_vars, term_t term) {
                Prolog.cons_functor_v(term, Prolog.new_functor(Prolog.new_atom(name), args.length), Term.putTerms(varnames_to_vars, args));
        }
        //==================================================================/
        //  Converting Prolog terms to JPL Terms
        //==================================================================/
        protected static Term getTerm1(Map varnames_to_vars, term_t term) {
                // ObjectHolder jthing_holder = new ObjectHolder();
                StringHolder name_holder = new StringHolder();
                IntHolder arity_holder = new IntHolder();
                Prolog.get_name_arity(term, name_holder, arity_holder); // assume it succeeds
                Term args[] = new Term[arity_holder.value];
                for (int i = 1; i <= arity_holder.value; i++) {
                        term_t termi = Prolog.new_term_ref();
                        Prolog.get_arg(i, term, termi);
                        args[i - 1] = Term.getTerm(varnames_to_vars, termi);
                }
                return new Compound(name_holder.value, args);
        }
        //==================================================================/
        //  Computing Substitutions
        //==================================================================/
        protected final void getSubst(Map varnames_to_Terms, Map vars_to_Vars) {
                Term.getSubsts(varnames_to_Terms, vars_to_Vars, args);
        }
        public boolean hasFunctor(int value, int arity) {
                return false;
        }
        public boolean hasFunctor(double value, int arity) {
                return false;
        }
}
//345678901234567890123456789012346578901234567890123456789012345678901234567890

---

jpl
Author(s): Lorenz Moesenlechner
autogenerated on Fri Jan 11 09:40:29 2013