calls the Query's goal to exhaustion
and returns an array of zero or more Hashtables of zero or more variablename-to-term bindings (each Hashtable represents a solution, in the order in which they were found).
This static method creates a Query whose goal is the given Term,
calls it to exhaustion,
and returns an array of zero or more Hashtables of zero or more variablename-to-term bindings (each Hashtable represents a solution, in the order in which they were found).
This static method creates a Query from the given Prolog source text fragment,
calls it to exhaustion,
and returns an array of zero or more Hashtables of zero or more variablename-to-term bindings (each Hashtable represents a solution, in the order in which they were found).
If text denotes (in traditional Prolog source syntax) a term containing N questionmark (?) symbols and there are N accompanying Term params,
this static method replaces each questionmark symbol by its respective param,
calls the resulting goal to exhaustion,
and returns an array of zero or more Hashtables of zero or more variablename-to-term bindings (each Hashtable represents a solution, in the order in which they were found).
If text denotes (in traditional Prolog source syntax) a term containing N questionmark (?) symbols
and there are N params, each questionmark symbol is replaced by its corresponding arg
to provide the new Query's goal: the resulting Query is called as described above.
The jpl.JPL class contains methods which allow (i) inspection and alteration
of the "default" initialisation arguments (ii) explicit initialisation
(iii) discovery of whether the Prolog engine is already initialised,
and if so, with what arguments.
Converts a (JPL) list of Name=Var pairs (as yielded by atom_to_term/3)
to a Map from Prolog variables (necessarily in term_t holders) to named JPL Variables
calls the Query's goal to exhaustion or until N solutions are found, whichever is sooner,
and returns an array containing (as possibly empty Hashtables of variablename-to-term bindings) every found solution (in the order in which they were found).
This static method creates a Query whose goal is the given Term,
calls it to exhaustion or until N solutions are found, whichever is sooner,
and returns an array containing (as possibly empty Hashtables of variablename-to-term bindings) every found solution (in the order in which they were found).
This static method creates a Query from the given Prolog source text fragment,
calls it to exhaustion or until N solutions are found, whichever is sooner,
and returns an array containing (as possibly empty Hashtables of variablename-to-term bindings) every found solution (in the order in which they were found).
If text denotes (in traditional Prolog source syntax) a term containing N questionmark (?) symbols and there are N accompanying params,
this static method replaces each questionmark symbol by its respective param,
calls the resulting goal to exhaustion or until N solutions are found, whichever is sooner,
and returns an array containing (as possibly empty Hashtables of variablename-to-term bindings) every found solution (in the order in which they were found).
This static method creates a Query (whose goal is the specified Term)
and calls it at most once, returning the first solution, if there is one, as a (possibly empty) Hashtable, else null.
This static method creates a Query from the given Prolog source text fragment,
and calls it at most once, returning the first solution, if there is one, as a (possibly empty) Hashtable, else null.
If text denotes (in traditional Prolog source syntax) a term containing N questionmark (?) symbols
and there are N params, each questionmark symbol is replaced by its respective param
to provide the goal of this query:
the resulting goal is then called (at most once) and the first solution, if there is one, is returned as a (possibly empty) Hashtable, else null.
If text denotes an atom, this constructor is shorthand for
new Query(new Compound(name,args)),
but if text denotes a term containing N query (?) symbols
and there are N args, each query is replaced by its corresponding arg
to provide the new Query's goal.
Converts a Prolog source text to a corresponding JPL Term (in which each Variable has the appropriate name from the source text), replacing successive occurrences of ? in the text by the
corresponding element of Term[] params.
Returns a prefix functional representation of a Compound of the form name(arg1,...),
where 'name' is quoted iff necessary (to be valid Prolog soutce text)
and each argument is represented according to its toString() method.
This static method converts a term_t, which is assumed to contain
a reference to a *consecutive* list of term_t references to a
String representation of a list of terms, in this case, a comma
separated list.