Util.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.Hashtable;
import java.util.Map;

//----------------------------------------------------------------------/
// Util
public final class Util {
        //------------------------------------------------------------------/
        // termArrayToList
        public static Term termArrayToList(Term[] terms) {
                Term list = new Atom("[]");

                for (int i = terms.length - 1; i >= 0; --i) {
                        list = new Compound(".", new Term[] { terms[i], list });
                }
                return list;
        }

        public static Term[] bindingsToTermArray(Map varnames_to_Terms) {
                Term[] ts = new Term[varnames_to_Terms.size()];

                for (java.util.Iterator i = varnames_to_Terms.keySet().iterator(); i.hasNext();) {
                        Variable k = (Variable) i.next();
                        ts[k.index] = (Term) (varnames_to_Terms.get(k));
                }
                return ts;
        }

        //------------------------------------------------------------------/
        // toString
        public static String toString(Map varnames_to_Terms) {
                if (varnames_to_Terms == null) {
                        return "[no solution]";
                }
                java.util.Iterator varnames = varnames_to_Terms.keySet().iterator();

                String s = "Bindings: ";
                while (varnames.hasNext()) {
                        String varname = (String) varnames.next();
                        s += varname + "=" + varnames_to_Terms.get(varname).toString() + "; ";
                }
                return s;
        }

        //------------------------------------------------------------------/
        // namevarsToMap
        public static Map namevarsToMap(Term nvs) {

                try {
                        Map vars_to_Vars = new Hashtable();
                        
                        /*
                        while (nvs.hasFunctor(".", 2) && ((Compound) nvs).arg(1).hasFunctor("=", 2)) {
                                Atom name = (Atom) ((Compound) ((Compound) nvs).arg(1)).arg(1); // get the Name of the =/2 pair
                                Variable var = (Variable) ((Compound) ((Compound) nvs).arg(1)).arg(2); // get the Var of the =/2 pair

                                vars_to_Vars.put(var.term_, new Variable(name.name())); // map the Prolog variable to a new, named Variable
                                nvs = ((Compound) nvs).arg(2); // advance to next list cell
                        }
                         */
                        while (nvs.hasFunctor(".", 2) && nvs.arg(1).hasFunctor("=", 2)) {
                                // the cast to Variable is necessary to access the (protected) .term_ field
                                vars_to_Vars.put(((Variable)nvs.arg(1).arg(2)).term_, new Variable(nvs.arg(1).arg(1).name())); // map the Prolog variable to a new, named Variable
                                nvs = nvs.arg(2); // advance to next list cell
                        }

                        // maybe oughta check that nvs is [] ?
                        return vars_to_Vars;
                } catch (java.lang.ClassCastException e) { // nvs is not of the expected structure
                        return null;
                }
        }

        //------------------------------------------------------------------/
        // textToTerm
        public static Term textToTerm(String text) {
                // it might be better to use PL_chars_to_term()
                Query q = new Query(new Compound("atom_to_term", new Term[] { new Atom(text), new Variable("Term"), new Variable("NVdict")}));
                q.open();
                Map s = q.getSubstWithNameVars();
                if (s != null) {
                        q.close();
                        return (Term) s.get("Term");
                } else {
                        return null;
                }
        }
        //
        // textParamsToTerm
        public static Term textParamsToTerm(String text, Term[] params) {
                return Util.textToTerm(text).putParams(params);
        }
        //
        public static Term stringArrayToList(String[] a) {
                Term list = new Atom("[]");
                for (int i = a.length - 1; i >= 0; i--) {
                        list = new Compound(".", new Term[]{new Atom(a[i]), list});
                }
                return list;
        }
        //
        public static Term intArrayToList(int[] a) {
                Term list = new Atom("[]");
                for (int i = a.length - 1; i >= 0; i--) {
                        list = new Compound(".", new Term[]{new jpl.Integer(a[i]), list});
                }
                return list;
        }
        //
        public static Term intArrayArrayToList(int[][] a) {
                Term list = new Atom("[]");
                for (int i = a.length - 1; i >= 0; i--) {
                        list = new Compound(".", new Term[]{intArrayToList(a[i]), list});
                }
                return list;
        }
        public static int listToLength(Term t) {
                int length = 0;
                Term head = t;
                while (head.hasFunctor(".", 2)) {
                        length++;
                        head = head.arg(2);
                }
                return (head.hasFunctor("[]", 0) ? length : -1);
        }
        public static Term[] listToTermArray(Term t) {
                try {
                        int len = t.listLength();
                        Term[] ts = new Term[len];

                        for (int i = 0; i < len; i++) {
                                ts[i] = t.arg(1);
                                t = t.arg(2);
                        }
                        return ts;
                } catch (JPLException e) {
                        throw new JPLException("Util.listToTermArray: term is not a proper list");
                }
        }

        public static String[] atomListToStringArray( Term t){
                int n = listToLength(t);
                String[] a;
                if ( n<0){
                        return null;
                } else {
                        a = new String[n];
                }
                int i = 0;
                Term head = t;
                while ( head.hasFunctor(".", 2)){
                        Term x = head.arg(1);
                        if ( x.isAtom()){
                                a[i++]=x.name();
                        } else {
                                return null;
                        }
                        head = head.arg(2);
                }
                return (head.hasFunctor("[]", 0) ? a : null );
        }
}

---

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