io.github.prolobjectlink.prolog

Interface PrologEngine

All Superinterfaces:

Iterable<PrologClause>

All Known Implementing Classes:

AbstractEngine

public interface PrologEngine
extends Iterable<PrologClause>

A PrologEngine instance is used in order to interact with the concrete prolog engine. Is used for interact with the Prolog database or to invoke a built-in predicate. It is initialized using a provider instance and calling new engine PrologProvider.newEngine()

 PrologProvider provider = Prolog.getProvider(Some_PrologProvider_Impl.class);
 PrologEngine engine = provider.newEngine();
 

The PrologProvider.newEngine(String) method is used if the specified file to consult is provided. The prolog engine have a life cycle on the user application. After create an instance we can consult any file with prolog programs using consult(Reader) or consult(String). If another prolog file need to be include in main memory we can use include(Reader) or include(String). We can include so much files as we needed.

 engine.consult("family.pl");
 engine.include("company.pl");
 engine.include("zoo.pl");
 

To check if the given goal have solution using the resolution engine mechanism we can use contains(String) or contains(PrologTerm, PrologTerm...). Both methods returning true if the given goal have solution or false in other case.

 boolean b = engine.clause("parent( pam, bob)");
 

To check if there are a clause in the prolog engine we can use clause(String) or clause(PrologTerm, PrologTerm...). This methods is based on the prolog engine built-in clause/2 that check if in the currents predicates exist a clause definition that match with the given clause. This methods return true if the given clause is defined in the prolog engine or false in other case. The following cases return true.

 engine.assertz("parent( pam, bob)");
 boolean b = engine.clause("parent( X, Y);
 boolean t = engine.clause("parent( pam, bob)")
 

Java Prolog Interface have an special interface to query to prolog engine about some specific clauses an operate over solution set. PrologQuery is the mechanism to query the prolog database loaded in prolog engine. The way to create a new prolog query is invoking query(String), query(PrologTerm, PrologTerm...) or query(PrologTerm[]). This interface have several methods to obtain one, at least N or all query results.

 PrologEngine engine = provider.newEngine("zoo.pl");
 PrologVariable x = provider.newVariable("X", 0);
 PrologQuery query = engine.query(provider.newStructure("dark", x));
 List<Object> solution = query.oneResult();
 for (int i = 0; i < solution.size(); i++) {
        System.out.println(solution.get(i));
 }
 

Java Prolog Interface have shortcuts methods to obtain queries result from the engine. The shortcuts methods to obtain one result are queryOne(PrologTerm), queryOne(String), queryOne(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).oneVariablesResult(). queryN The shortcuts methods to obtain all results are queryAll(PrologTerm), queryAll(String), queryAll(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).allVariablesResult(). After create an empty prolog engine and load any prolog program, we can modify the program/database. For this propose we have the methods asserta(String), asserta(PrologTerm,PrologTerm...) or assertz(String), assertz(PrologTerm,PrologTerm...). The asserta methods are used when we need store a prolog clause term on top in the clause family and assertz by other hand, are when we need store a prolog clause term on the tail in the clause family.

 engine.asserta("grandparent(X,Z):-parent(X,Y),parent(Y,Z)");
 engine.asserta("parent( pat, jim)");
 

 engine.assertz("parent( pat, jim)");
 engine.assertz("grandparent(X,Z):-parent(X,Y),parent(Y,Z)");
 

For remove clauses in the main memory program if the clause exist can be used retract(String) or retract(PrologTerm, PrologTerm...). Both methods after build internal clause representation find the specific clause and if this exist remove it. By other hand if we need remove all clause family we can use abolish(String, int). This method remove all predicates that match with the predicate indicator (PI) formed by the concatenation of the given string functor and integer arity separated by slash (functor/arity).

 engine.retract("parent( tom, bob)");
 

 engine.abolish("parent", 2);
 

All change that take place in the current engine can save to some specific file using persist(String) or persist(Writer).

 engine.assertz(provider.newStructure("parent", pam, bob));
 engine.assertz(provider.newStructure("parent", tom, bob));
 engine.assertz(provider.newStructure("parent", tom, liz));
 engine.assertz(provider.newStructure("parent", bob, ann));
 engine.assertz(provider.newStructure("parent", bob, pat));
 engine.assertz(provider.newStructure("parent", pat, jim));
 
 engine.persist("family.pl");
 

By the last dispose() clear program in main memory. Release all resources used and prepare the current engine for realize some new task.

 engine.dispose();
 

An additional capability of the prolog engine is the Iterable implementation. This allow to prolog engine iterate over all user defined clauses using a for-each loop or iterator loop.

 for (PrologClause c : engine) {
        // do something
 }
 

 Iterator<?> i = engine.iterator();
 while (i.hasNext()) {
        // do something
 }
 

The shortcuts methods to obtain N results are PrologEngine.queryN(Class), PrologEngine.queryN(Object), PrologEngine.queryN(PrologTerm), PrologEngine.queryN(String), PrologEngine.queryN(Class, Class...), PrologEngine.queryN(Object, Object...), PrologEngine.queryN(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).nVariablesResult(). Java Prolog Interface have shortcuts methods to obtain queries result from the engine. The shortcuts methods to obtain one result are PrologEngine.queryOne(Class), PrologEngine.queryOne(Object), PrologEngine.queryOne(PrologTerm), PrologEngine.queryOne(String), PrologEngine.queryOne(Class, Class...), PrologEngine.queryOne(Object, Object...), PrologEngine.queryOne(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).oneVariablesResult(). The shortcuts methods to obtain N results are PrologEngine.queryN(Class), PrologEngine.queryN(Object), PrologEngine.queryN(PrologTerm), PrologEngine.queryN(String), PrologEngine.queryN(Class, Class...), PrologEngine.queryN(Object, Object...), PrologEngine.queryN(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).nVariablesResult(). The shortcuts methods to obtain all results are PrologEngine.queryAll(Class), PrologEngine.queryAll(Object), PrologEngine.queryAll(PrologTerm), PrologEngine.queryAll(String), PrologEngine.queryAll(Class, Class...), PrologEngine.queryAll(Object, Object...), PrologEngine.queryAll(PrologTerm, PrologTerm...). This methods are equivalent to call PrologEngine.query(...).allVariablesResult().

Since:

1.0

Author:

Jose Zalacain

Method Summary

Modifier and Type	Method and Description
void	abolish(String functor, int arity) Remove all predicates that match with the predicate indicator (PI) formed by the concatenation of the given string functor and integer arity separated by slash (functor/arity).
void	asserta(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist.
void	asserta(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
void	asserta(String stringClause) Parse the string creating internal prolog clause and add the clause in the main memory program if the clause non exist.
void	assertz(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist.
void	assertz(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
void	assertz(String stringClause) Parse the string creating internal prolog clause and add the clause in the main memory program if the clause non exist.
boolean	clause(PrologTerm term) Find a rule specified by the rule head and rule body in main memory program that unify with the given clause returning true in this case.If the clause not exist in main memory program or exist but not unify with the given clause false value is returned.
boolean	clause(PrologTerm head, PrologTerm... body) Find a rule specified by the rule head and rule body in main memory program that unify with the given clause returning true in this case.If the clause not exist in main memory program or exist but not unify with the given clause false value is returned.
boolean	clause(String stringClause) Parse the string creating internal prolog clause and returning true if the clause in the main memory program unify with the given clause.
void	consult(Reader reader) Consult a prolog program from specified reader parsing the prolog program and put this program into prolog engine.
void	consult(String path) Consult a file specified by the string path loading an parsing the prolog program.
boolean	contains(PrologTerm goal) Check if the given goal array have solution using the resolution engine mechanism.
boolean	contains(PrologTerm goal, PrologTerm... goals) Check if the given goal array have solution using the resolution engine mechanism.
boolean	contains(String goal) Parse the string creating internal prolog clause and returning true if the given goal have solution using the resolution engine mechanism.
boolean	currentOperator(int priority, String specifier, String operator) Check if in the wrapped prolog engine is defined some particular operator specified by your Priority, Specifier and Operator.
Set<PrologOperator>	currentOperators() Operator set defined in the wrapped prolog engine.
boolean	currentPredicate(String functor, int arity) Check if in the wrapped prolog engine is defined some particular predicate specified by your predicate indicator (PI = functor/arity).
Set<PrologIndicator>	currentPredicates() Predicate set defined in the wrapped prolog engine.
void	dispose() Clear program in main memory.
Set<PrologIndicator>	getBuiltIns() Predicate set defined by the supported built-ins predicate in the wrapped prolog engine.
String	getLicense() License of the wrapped engine.
PrologLogger	getLogger() Get the prolog system logger instance to report any errors or exceptions
String	getName() Name of the wrapped engine.
String	getOSArch() Return the host operating system architecture.
String	getOSName() Return the host operating system name.
String	getOSVersion() Return the host operating system version.
Set<PrologIndicator>	getPredicates() User defined predicate set defined in the wrapped prolog engine.
PrologProgram	getProgram() Make and return a copy of the program.
Set<PrologClause>	getProgramClauses() Make and return a copy of the clause set present in the current engine.
Map<String,List<PrologClause>>	getProgramMap() Make and return a copy of the clause map present in the current engine.
int	getProgramSize() Number of clauses in the current engine.
PrologProvider	getProvider() Get a Prolog provider instance hold in the current engine.
String	getVendor() Under-laying engine vendor
String	getVersion() Version of the wrapped engine.
void	include(Reader reader) Consult a prolog program from specified reader parsing the prolog program and include this program into current prolog engine.
void	include(String path) Consult a file specified by the string path loading an parsing the prolog program and include the loaded program into current engine.
boolean	isProgramEmpty() Check if the program in main memory is empty returning true if the clause number in the program is 0 and false in otherwise.
Map<String,PrologTerm>	match(PrologTerm t1, PrologTerm t2) Match to other term returning list of substitutions.
PrologClauseBuilder	newClauseBuilder() Create a new clause builder instance to build prolog clauses programmatically.
PrologQueryBuilder	newQueryBuilder() Create a new query builder instance to build prolog goal programmatically.
void	operator(int priority, String specifier, String operator) Define an operator in the wrapped prolog engine with priority between 0 and 1200 and associativity determined by specifier according to the table below Specification table Specifier Type Associativity fx prefix no fy prefix yes xf postfix no yf postfix yes xfx infix no yfx infix left xfy infix right void persist(String path) Save the prolog program present in the current engine to some specific file specified by string path. void persist(Writer writer) Write the prolog clauses in program present in the current engine using the given driver. PrologQuery query(PrologTerm goal) PrologQuery query(PrologTerm[] terms) Create a new query being the goal the given prolog term array. PrologQuery query(PrologTerm term, PrologTerm... terms) Create a new query with at least one prolog term goal. PrologQuery query(String query) Create a new query being the goal the given string with prolog syntax. List<Map<String,PrologTerm>> queryAll(PrologTerm goal) List<Map<String,PrologTerm>> queryAll(PrologTerm term, PrologTerm... terms) Create a new prolog query and return the list of prolog terms that conform the solution set for the current query. List<Map<String,PrologTerm>> queryAll(String goal) Create a new prolog query and return the list of prolog terms that conform the solution set for the current query. List<Map<String,PrologTerm>> queryN(int n, PrologTerm goal) List<Map<String,PrologTerm>> queryN(int n, PrologTerm term, PrologTerm... terms) Create a new prolog query and return the list of (N) prolog terms that conform the solution set for the current query. List<Map<String,PrologTerm>> queryN(int n, String goal) Create a new prolog query and return the list of (N) prolog terms that conform the solution set for the current query. Map<String,PrologTerm> queryOne(PrologTerm goal) Map<String,PrologTerm> queryOne(PrologTerm term, PrologTerm... terms) Create a new prolog query and return the prolog terms that conform the solution set for the current query. Map<String,PrologTerm> queryOne(String goal) Create a new prolog query and return the prolog terms that conform the solution set for the current query. void retract(PrologTerm term) Remove a fact specified by the head if the specified fact clause exist. void retract(PrologTerm head, PrologTerm... body) Remove a rule specified by the rule head and rule body if the specified rule clause exist. void retract(String stringClause) Parse the string creating internal prolog clause and remove the clause in the main memory program if the clause exist. boolean runOnLinux() Check if the host operating system name refer to Linux OS. boolean runOnOSX() Check if the host operating system name refer to OsX. boolean runOnWindows() Check if the host operating system name refer to Windows OS. boolean unify(PrologTerm t1, PrologTerm t2) Check that two terms (x and y) unify. List<String> verify() Test the correct integration between under-laying prolog engine and top level interface. Methods inherited from interface java.lang.Iterable forEach, iterator, spliterator Method Detail runOnWindows boolean runOnWindows() Check if the host operating system name refer to Windows OS. Returns: true if the host operating system name refer to Windows OS and false otherwise. Since: 1.0 runOnLinux boolean runOnLinux() Check if the host operating system name refer to Linux OS. Returns: true if the host operating system name refer to Linux OS and false otherwise. Since: 1.0 runOnOSX boolean runOnOSX() Check if the host operating system name refer to OsX. Returns: true if the host operating system name refer to OsX and false otherwise. Since: 1.0 getOSName String getOSName() Return the host operating system name. Is a shortcut to System.getProperty("os.name");. Returns: the host operating system name. Since: 1.0 getOSVersion String getOSVersion() Return the host operating system version. Is a shortcut to System.getProperty("os.version");. Returns: the host operating system version. Since: 1.1 getOSArch String getOSArch() Return the host operating system architecture. Is a shortcut to System.getProperty("os.arch");. Returns: the host operating system architecture. Since: 1.0 verify List<String> verify() Test the correct integration between under-laying prolog engine and top level interface. Return a string list with the needed conditions to link the under-laying prolog engine. if the under-laying prolog engine is linked the returned set only contain the "OK" string indicating a correct integration. Returns: string list with only "OK" string if the prolog engine integration is correct or the conditions string list needed to link the prolog engine. Since: 1.0 consult void consult(String path) Consult a file specified by the string path loading an parsing the prolog program. If the prolog program contains syntax error a syntax exception should be raised. Parameters: path - location of the file to be consulted Since: 1.0 consult void consult(Reader reader) Consult a prolog program from specified reader parsing the prolog program and put this program into prolog engine. If the prolog program contains syntax error a syntax exception should be raised. Parameters: reader - The reader to read the prolog program from character streams Since: 1.0 include void include(String path) Consult a file specified by the string path loading an parsing the prolog program and include the loaded program into current engine. If the prolog program contains syntax error a syntax exception should be raised. Parameters: path - location of the file to be included Since: 1.0 include void include(Reader reader) Consult a prolog program from specified reader parsing the prolog program and include this program into current prolog engine. If the prolog program contains syntax error a syntax exception should be raised. Parameters: reader - The reader to read the prolog program from character streams Since: 1.0 persist void persist(String path) Save the prolog program present in the current engine to some specific file specified by string path. Parameters: path - location of the file. Since: 1.0 persist void persist(Writer writer) Write the prolog clauses in program present in the current engine using the given driver. Parameters: writer - writer for write prolog clauses in the program. Since: 1.0 abolish void abolish(String functor, int arity) Remove all predicates that match with the predicate indicator (PI) formed by the concatenation of the given string functor and integer arity separated by slash (functor/arity). engine.abolish("parent", 2); // remove all parent/2 predicates Parameters: functor - string functor that identify the predicate family to be remove. arity - argument number that identify the predicate family to be remove. Since: 1.0 asserta void asserta(String stringClause) Parse the string creating internal prolog clause and add the clause in the main memory program if the clause non exist. If the clause exist, will not overwritten and the clause will not added. The string have prolog fact or rule syntax. The added clause will be the first clause for a clause lot with the same predicate indicator (PI). engine.asserta("grandparent(X,Z):-parent(X,Y),parent(Y,Z)"); engine.asserta("parent( pat, jim)"); engine.asserta("parent( bob, pat)"); engine.asserta("parent( bob, ann)"); engine.asserta("parent( tom, liz)"); engine.asserta("parent( tom, bob)"); engine.asserta("parent( pam, bob)"); Parameters: stringClause - - string for create internal prolog clause Since: 1.0 asserta void asserta(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist. If the clause exist, will not overwritten and the clause will not added. The added clause will be the first clause for a clause lot with the same predicate indicator (PI). Parameters: term - term to be added Since: 1.1 asserta void asserta(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist. If the rule clause exist, will not overwritten and the clause will not added. The head term is the first argument and the body is constituted by the terms array followed of the rule head. If the body array is empty the clause will be considered like fact specified by head only. The added clause will be the first clause for a clause lot with the same predicate indicator (PI). The shared variables in the clause are declared once and use for build the terms that conform the clause to be added String parent = "parent"; String grandparent = "grandparent"; PrologAtom pam = provider.newAtom("pam"); PrologAtom bob = provider.newAtom("bob"); PrologAtom ann = provider.newAtom("ann"); PrologAtom pat = provider.newAtom("pat"); PrologVariable x = provider.newVariable("X"); PrologVariable y = provider.newVariable("Y"); PrologVariable z = provider.newVariable("Z"); engine.asserta(provider.newStructure(grandparent, x, z), provider.newStructure(parent, x, y), provider.newStructure(parent, y, z)); engine.asserta(provider.newStructure(parent, pat, jim)); engine.asserta(provider.newStructure(parent, bob, pat)); engine.asserta(provider.newStructure(parent, bob, ann)); engine.asserta(provider.newStructure(parent, tom, liz)); engine.asserta(provider.newStructure(parent, tom, bob)); engine.asserta(provider.newStructure(parent, pam, bob)); Parameters: head - head of rule body - array of terms that compound the body of the rule Since: 1.0 assertz void assertz(String stringClause) Parse the string creating internal prolog clause and add the clause in the main memory program if the clause non exist. If the clause exist, will not overwritten and the clause will not added. The string have prolog fact or rule syntax. The added clause will be the last clause for a clause lot with the same predicate indicator (PI). engine.assertz("parent( pam, bob)"); engine.assertz("parent( tom, bob)"); engine.assertz("parent( tom, liz)"); engine.assertz("parent( bob, ann)"); engine.assertz("parent( bob, pat)"); engine.assertz("parent( pat, jim)"); engine.assertz("grandparent(X,Z):-parent(X,Y),parent(Y,Z)"); Parameters: stringClause - string clause to be added Since: 1.0 assertz void assertz(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist. If the clause exist, will not overwritten and the clause will not added. The added clause will be the last clause for a clause lot with the same predicate indicator (PI). Parameters: term - term to be added Since: 1.1 assertz void assertz(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist. If the rule clause exist, will not overwritten and the clause will not added. The head term is the first argument and the body is constituted by the terms array followed of the rule head. If the body array is empty the clause will be considered like fact specified by head only. The added clause will be the last clause for a clause lot with the same predicate indicator (PI). The shared variables in the clause are declared once and use for build the terms that conform the clause to be added String parent = "parent"; String grandparent = "grandparent"; PrologAtom pam = provider.newAtom("pam"); PrologAtom bob = provider.newAtom("bob"); PrologAtom ann = provider.newAtom("ann"); PrologAtom pat = provider.newAtom("pat"); PrologVariable x = provider.newVariable("X"); PrologVariable y = provider.newVariable("Y"); PrologVariable z = provider.newVariable("Z"); engine.assertz(provider.newStructure(parent, pam, bob)); engine.assertz(provider.newStructure(parent, tom, bob)); engine.assertz(provider.newStructure(parent, tom, liz)); engine.assertz(provider.newStructure(parent, bob, ann)); engine.assertz(provider.newStructure(parent, bob, pat)); engine.assertz(provider.newStructure(parent, pat, jim)); engine.assertz(provider.newStructure(grandparent, x, z), provider.newStructure(parent, x, y), provider.newStructure(parent, y, z)); Parameters: head - head of rule body - array of terms that compound the body of the rule Since: 1.0 clause boolean clause(String stringClause) Parse the string creating internal prolog clause and returning true if the clause in the main memory program unify with the given clause. If the clause not exist in main memory program or exist but not unify with the given clause false value is returned. The string have prolog fact or rule syntax. boolean b = engine.clause("parent( pam, bob)"); boolean b = engine.clause("grandparent(X,Z):-parent(X,Y),parent(Y,Z)"); Parameters: stringClause - string clause to be match Returns: true if the clause in the main memory program unify with the given clause, false otherwise Since: 1.0 clause boolean clause(PrologTerm term) Find a rule specified by the rule head and rule body in main memory program that unify with the given clause returning true in this case.If the clause not exist in main memory program or exist but not unify with the given clause false value is returned. The shared variables in the clause are declared once and use for build the terms that conform the clause to be found. Parameters: term - term to be match with some clause in main memory program Returns: true if the clause in the main memory program unify with the clause equivalent to the given term, false otherwise Since: 1.1 clause boolean clause(PrologTerm head, PrologTerm... body) Find a rule specified by the rule head and rule body in main memory program that unify with the given clause returning true in this case.If the clause not exist in main memory program or exist but not unify with the given clause false value is returned. The head term is the first argument and the body is constituted by the terms array followed of the rule head. If the body array is empty the clause will be considered like fact specified by head only. The shared variables in the clause are declared once and use for build the terms that conform the clause to be found. String parent = "parent"; PrologAtom pam = provider.newAtom("pam"); PrologAtom bob = provider.newAtom("bob"); boolean b = engine.clause(provider.newStructure(parent, pam, bob)); String grandparent = "grandparent"; PrologVariable x = provider.newVariable("X"); PrologVariable y = provider.newVariable("Y"); PrologVariable z = provider.newVariable("Z"); boolean b = engine.clause(provider.newStructure(grandparent, x, z), provider.newStructure(parent, x, y), provider.newStructure(parent, y, z)); Parameters: head - head of rule body - array of terms that compound the body of the rule Returns: true if the clause in the main memory program unify with the given clause, false otherwise Since: 1.0 retract void retract(String stringClause) Parse the string creating internal prolog clause and remove the clause in the main memory program if the clause exist. The string have prolog fact or rule syntax. engine.retract("parent( pam, bob)."); engine.retract("parent( tom, bob)."); engine.retract("parent( tom, liz)."); engine.retract("parent( bob, ann)."); engine.retract("parent( bob, pat)."); engine.retract("parent( pat, jim)."); engine.retract("grandparent(X,Z):-parent(X,Y),parent(Y,Z)"); Parameters: stringClause - string clause to be removed Since: 1.0 retract void retract(PrologTerm term) Remove a fact specified by the head if the specified fact clause exist. The shared variables in the clause are declared once and use for build the terms that conform the clause to be removed. Parameters: term - fact to be removed Since: 1.1 retract void retract(PrologTerm head, PrologTerm... body) Remove a rule specified by the rule head and rule body if the specified rule clause exist. The head term is the first argument and the body is constituted by the terms array followed of the rule head. If the body array is empty the clause will be considered like fact specified by head only. The shared variables in the clause are declared once and use for build the terms that conform the clause to be removed. String parent = "parent"; String grandparent = "grandparent"; PrologAtom pam = provider.newAtom("pam"); PrologAtom bob = provider.newAtom("bob"); PrologAtom ann = provider.newAtom("ann"); PrologAtom pat = provider.newAtom("pat"); PrologVariable x = provider.newVariable("X"); PrologVariable y = provider.newVariable("Y"); PrologVariable z = provider.newVariable("Z"); engine.retract(provider.newStructure(parent, pam, bob)); engine.retract(provider.newStructure(parent, tom, bob)); engine.retract(provider.newStructure(parent, tom, liz)); engine.retract(provider.newStructure(parent, bob, ann)); engine.retract(provider.newStructure(parent, bob, pat)); engine.retract(provider.newStructure(parent, pat, jim)); engine.retract(provider.newStructure(grandparent, x, z), provider.newStructure(parent, x, y), provider.newStructure(parent, y, z)); Parameters: head - head of rule body - array of terms that compound the body of the rule Since: 1.0 unify boolean unify(PrologTerm t1, PrologTerm t2) Check that two terms (x and y) unify. Prolog unification algorithm is based on three principals rules: If x and y are atomics constants then x and y unify only if they are same object. If x is a variable and y is anything then they unify and x is instantiated to y. Conversely, if y is a variable then this is instantiated to x. If x and y are structured terms then unify only if they match (equals funtor and arity) and all their correspondents arguments unify. Parameters: t1 - the term to unify. t2 - the term to unify. Returns: true if the specified term unify whit the current term, false otherwise. Since: 1.0 match Map<String,PrologTerm> match(PrologTerm t1, PrologTerm t2) Match to other term returning list of substitutions. Used to compute the most general unifier. Parameters: t1 - the term to unify. t2 - the term to unify. Returns: true if the specified term unify whit the current term, false otherwise. Since: 1.2 contains boolean contains(String goal) Parse the string creating internal prolog clause and returning true if the given goal have solution using the resolution engine mechanism. If wrapped engine not support a dedicated method then contains can be defined like query(goal).hasSolution() Parameters: goal - goal to be queried Returns: true if the given goal has solution Since: 1.0 contains boolean contains(PrologTerm goal) Check if the given goal array have solution using the resolution engine mechanism. If wrapped engine not support a dedicated method then contains can be defined like: query(goal).hasSolution() Parameters: goal - goal to be checked Returns: true if the given goal has solution Since: 1.1 contains boolean contains(PrologTerm goal, PrologTerm... goals) Check if the given goal array have solution using the resolution engine mechanism. If wrapped engine not support a dedicated method then contains can be defined like: query(goal).hasSolution() Parameters: goal - goal to be checked goals - goals array with the rest of conjunctive goals term (can be empty) Returns: true if the given goal has solution Since: 1.0 query PrologQuery query(String query) Create a new query being the goal the given string with prolog syntax. The query creation process call the wrapped prolog engine and after query creation the query instance is ready to use. This particular query method can raise an syntax exception if the string query have prolog errors. PrologQuery query = engine.query("parent(X, Y)"); Parameters: query - string goal with prolog syntax. Returns: a new query instance. Since: 1.0 query PrologQuery query(PrologTerm goal) Parameters: goal - Returns: Since: 1.1 query PrologQuery query(PrologTerm[] terms) Create a new query being the goal the given prolog term array. The given array is treated like a conjunctive goal and after success the first element the next term will be resolved. The query creation process call the wrapped prolog engine and after query creation the query instance is ready to use. PrologTerm x = provider.newVariable("X", 0); PrologTerm dark = provider.newStructure("dark", x); PrologTerm big = provider.newStructure("big", x); PrologTerm[] goals = new PrologTerm[] { dark, big }; PrologQuery query = engine.query(goals); Parameters: terms - prolog term array to be query. Returns: a new query instance. Since: 1.0 query PrologQuery query(PrologTerm term, PrologTerm... terms) Create a new query with at least one prolog term goal. The rest terms are treated like a conjunctive goal and after success the first element the next term will be resolved. The query creation process call the wrapped prolog engine and after query creation the query instance is ready to use. PrologTerm x = provider.newVariable("X", 0); PrologTerm dark = provider.newStructure("dark", x); PrologTerm big = provider.newStructure("big", x); PrologQuery query = engine.query(dark, big); Parameters: term - prolog term to be query terms - prolog term array to be query. Returns: a new query instance. Since: 1.0 queryOne Map<String,PrologTerm> queryOne(String goal) Create a new prolog query and return the prolog terms that conform the solution set for the current query. The solution set is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. List<Map<String, PrologTerm>> m = engine.queryAll("parent(X, Y)"); Parameters: goal - string query with prolog format. Returns: variable name - variable instance (key - value) map that conform the solution set for the current query. Since: 1.0 queryOne Map<String,PrologTerm> queryOne(PrologTerm goal) Parameters: goal - Returns: Since: 1.1 queryOne Map<String,PrologTerm> queryOne(PrologTerm term, PrologTerm... terms) Create a new prolog query and return the prolog terms that conform the solution set for the current query. The solution set is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. PrologVariable x = provider.newVariable("X", 0); PrologVariable y = provider.newVariable("Y", 1); Map<String, PrologTerm> m = engine.queryOne(provider.newStructure("parent", x, y)); Parameters: term - prolog term to be query terms - prolog term array to be query. Returns: variable name - variable instance (key - value) map that conform the solution set for the current query. Since: 1.0 queryN List<Map<String,PrologTerm>> queryN(int n, String goal) Create a new prolog query and return the list of (N) prolog terms that conform the solution set for the current query. Each list item is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. Parameters: n - query result instance number goal - string with prolog syntax to be query Returns: the list of prolog terms that conform the solution set for the current query. Since: 1.0 queryN List<Map<String,PrologTerm>> queryN(int n, PrologTerm goal) Parameters: n - goal - Returns: Since: 1.1 queryN List<Map<String,PrologTerm>> queryN(int n, PrologTerm term, PrologTerm... terms) Create a new prolog query and return the list of (N) prolog terms that conform the solution set for the current query. Each list item is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. PrologVariable x = provider.newVariable("X", 0); PrologVariable y = provider.newVariable("Y", 1); List<Map<String, PrologTerm>> m = engine.queryN(5, provider.newStructure("parent", x, y)); Parameters: n - query result instance number term - prolog term to be query terms - prolog term array to be query. Returns: the list of prolog terms that conform the solution set for the current query. Since: 1.0 queryAll List<Map<String,PrologTerm>> queryAll(String goal) Create a new prolog query and return the list of prolog terms that conform the solution set for the current query. Each list item is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. Parameters: goal - string with prolog syntax to be query Returns: the list of prolog terms that conform the solution set for the current query. Since: 1.0 queryAll List<Map<String,PrologTerm>> queryAll(PrologTerm goal) Parameters: goal - Returns: Since: 1.1 queryAll List<Map<String,PrologTerm>> queryAll(PrologTerm term, PrologTerm... terms) Create a new prolog query and return the list of prolog terms that conform the solution set for the current query. Each list item is a prolog terms map and every map entry is a pair variable name and variable instance value for the variables not anonymous involved in the query. PrologVariable x = provider.newVariable("X", 0); PrologVariable y = provider.newVariable("Y", 1); List<Map<String, PrologTerm>> m = engine.queryAll(provider.newStructure("parent", x, y)); Parameters: term - prolog term to be query terms - prolog term array to be query. Returns: the list of prolog terms that conform the solution set for the current query. Since: 1.0 newClauseBuilder PrologClauseBuilder newClauseBuilder() Create a new clause builder instance to build prolog clauses programmatically. Returns: a new clause builder instance Since: 1.0 newQueryBuilder PrologQueryBuilder newQueryBuilder() Create a new query builder instance to build prolog goal programmatically. Returns: a new query builder instance Since: 1.0 operator void operator(int priority, String specifier, String operator) Define an operator in the wrapped prolog engine with priority between 0 and 1200 and associativity determined by specifier according to the table below Specification table Specifier Type Associativity fx prefix no fy prefix yes xf postfix no yf postfix yes xfx infix no yfx infix left xfy infix right Parameters: priority - operator priority between 0 and 1200 specifier - associative and position of the operator operator - operator to be defined Since: 1.0 currentPredicate boolean currentPredicate(String functor, int arity) Check if in the wrapped prolog engine is defined some particular predicate specified by your predicate indicator (PI = functor/arity). If the predicate is defined by prolog engine built-in or by user definition return true and false in other case. If wrapped engine not support a dedicated method the currentPredicate(String, int) will be defined like currentPredicates().contains(new PredicateIndicator(functor, arity)); Parameters: functor - name of the predicate to be check. arity - argument number of the predicate to be check. Returns: true in functor/arity predicate is defined and false otherwise. Since: 1.0 currentOperator boolean currentOperator(int priority, String specifier, String operator) Check if in the wrapped prolog engine is defined some particular operator specified by your Priority, Specifier and Operator. If the operator is defined by prolog engine built-in or by user definition return true or false in other case. If wrapped engine not support a dedicated method the currentOperator(int, String, String) will be defined like currentOperators().contains(new PrologOperator(priority, specifier, operator)); Parameters: priority - operator priority between 0 and 1200 specifier - associative and position of the operator operator - operator to be checked Returns: true if the operator is defined by prolog engine built-in or by user definition, false otherwise. Since: 1.0 currentPredicates Set<PrologIndicator> currentPredicates() Predicate set defined in the wrapped prolog engine. The predicate set will be constituted by the supported built-ins predicate in the wrapped prolog engine and user defined predicates present in the prolog program/database. More formally current predicate set is defined by the union between user defined predicates and prolog engine built-ins. Set<PrologIndicator> cp = new HashSet<PrologIndicator>(); cp.addAll(getPredicates()); cp.addAll(getBuiltIns()); Returns: Defined Predicate Set. Since: 1.0 currentOperators Set<PrologOperator> currentOperators() Operator set defined in the wrapped prolog engine. The operator set will be constituted by the supported built-ins operator in the wrapped prolog engine and user defined operators present in the prolog program/database. Returns: defined operator set. Since: 1.0 getProgramMap Map<String,List<PrologClause>> getProgramMap() Make and return a copy of the clause map present in the current engine. The map key is a functor/arity string and the value is a prolog clause family list. Returns: a clause map present in the current engine. Since: 1.0 getProgramClauses Set<PrologClause> getProgramClauses() Make and return a copy of the clause set present in the current engine. Returns: a clause set present in the current engine. Since: 1.0 getProgram PrologProgram getProgram() Make and return a copy of the program. Returns: a program in the current engine. Since: 1.1 getProgramSize int getProgramSize() Number of clauses in the current engine. Returns: number of clauses in the engine. Since: 1.0 isProgramEmpty boolean isProgramEmpty() Check if the program in main memory is empty returning true if the clause number in the program is 0 and false in otherwise. If wrapped engine not support a dedicated method isProgramEmpty() will be defined like PrologEngine#getProgramSize()==0;. Returns: true if the clause number in the program is 0 and false in otherwise. Since: 1.0 getPredicates Set<PrologIndicator> getPredicates() User defined predicate set defined in the wrapped prolog engine. The predicate set will be constituted by user defined predicates present in the prolog program/database. The supported built-ins predicate in the wrapped prolog engine not be include in this set. Returns: User Defined Predicate Set. Since: 1.0 getBuiltIns Set<PrologIndicator> getBuiltIns() Predicate set defined by the supported built-ins predicate in the wrapped prolog engine. The user defined predicates in the wrapped prolog engine not be include in this set. Returns: built-ins predicates set. Since: 1.0 getProvider PrologProvider getProvider() Get a Prolog provider instance hold in the current engine. Returns: a Prolog provider instance. Since: 1.0 getLogger PrologLogger getLogger() Get the prolog system logger instance to report any errors or exceptions Returns: prolog system logger instance Since: 1.0 getLicense String getLicense() License of the wrapped engine. Returns: String license of the wrapped engine. Since: 1.0 getVersion String getVersion() Version of the wrapped engine. Returns: String version of the wrapped engine. Since: 1.0 getVendor String getVendor() Under-laying engine vendor Returns: engine vendor Since: 1.1 getName String getName() Name of the wrapped engine. Returns: String name of the wrapped engine. Since: 1.0 dispose void dispose() Clear program in main memory. Release all resources used and prepare the current engine for realize some new task. Since: 1.0 Skip navigation links Overview Package Class Use Tree Deprecated Index Help Prev Class Next Class Frames No Frames All Classes Summary: Nested | Field | Constr | Method Detail: Field | Constr | Method Copyright © 2020–2024 Prolobjectlink Project. All rights reserved.