Uses of Interface
io.github.prolobjectlink.prolog.PrologTerm

Packages that use PrologTerm

Package	Description
io.github.prolobjectlink.prolog

Uses of PrologTerm in io.github.prolobjectlink.prolog

Subinterfaces of PrologTerm in io.github.prolobjectlink.prolog

Modifier and Type	Interface and Description
interface	PrologAtom Represent the Prolog atom data type.
interface	PrologDouble Prolog term that represent a double precision floating point number.
interface	PrologEntry PrologEntry is key-value pair of PrologTerm.
interface	PrologFloat Prolog term that represent a single precision floating point number.
interface	PrologInteger Prolog term that represent a integer number.
interface	PrologList Represent prolog list compound term.
interface	PrologLong Prolog term that represent a long integer number.
interface	PrologMap A PrologTerm that maps PrologTerm keys to PrologTerm values.
interface	PrologNumber Represent all Prolog number data type.
interface	PrologReference PrologReference is a specialized Term with an Object field, representing Prolog references to Java objects (or to null).
interface	PrologStructure Represent structured prolog compound term.
interface	PrologVariable Prolog term that represent variable data type.

Classes in io.github.prolobjectlink.prolog that implement PrologTerm

Modifier and Type	Class and Description
class	AbstractCompounds
class	AbstractTerm Partial implementation of PrologTerm interface.
class	PrologBuiltin

Methods in io.github.prolobjectlink.prolog with type parameters of type PrologTerm

Modifier and Type	Method and Description
<T extends PrologTerm> T	PrologTerm.cast() Casts the current PrologTerm to the class or interface represented by this Class object.
<T extends PrologTerm> T	AbstractTerm.cast()
<T extends PrologTerm> T	PrologProvider.cast(PrologTerm term) Casts a PrologTerm to the class or interface represented by this Class object.
protected <T extends PrologTerm> T	AbstractTerm.cast(PrologTerm term) Casts a PrologTerm to the class or interface represented by this Class object.
<T extends PrologTerm> T	AbstractProvider.cast(PrologTerm term)
protected <T extends PrologTerm> T	AbstractTerm.cast(PrologTerm term, Class<T> type) Casts a PrologTerm to the class or interface represented by this Class object.
protected <T extends PrologTerm> T	AbstractProvider.cast(PrologTerm term, Class<T> type) Casts a PrologTerm to the class or interface represented by this Class object.
protected <K extends PrologTerm> K	AbstractTerm.toTerm(Object o, Class<K> from)
protected <K extends PrologTerm> K	AbstractQuery.toTerm(Object o, Class<K> from)
<K extends PrologTerm> K	AbstractProvider.toTerm(Object o, Class<K> from)
protected <K extends PrologTerm> K	AbstractEngine.toTerm(Object o, Class<K> from)
<K extends PrologTerm> K	AbstractConverter.toTerm(Object o, Class<K> from)
protected <K extends PrologTerm> K[]	AbstractTerm.toTermArray(Object[] os, Class<K[]> from)
<K extends PrologTerm> K[]	AbstractProvider.toTermArray(Object[] os, Class<K[]> from)
<K extends PrologTerm> K[]	AbstractConverter.toTermArray(Object[] os, Class<K[]> from)
<K extends PrologTerm,V> Map<String,PrologTerm>	AbstractProvider.toTermMap(Map<String,V> map, Class<K> from)
<K extends PrologTerm,V> Map<String,PrologTerm>	AbstractConverter.toTermMap(Map<String,V> map, Class<K> from)
protected <K extends PrologTerm,V> Map<String,PrologTerm>[]	AbstractQuery.toTermMapArray(Map<String,V>[] map, Class<K> from)
<K extends PrologTerm,V> Map<String,PrologTerm>[]	AbstractProvider.toTermMapArray(Map<String,V>[] map, Class<K> from)
protected <K extends PrologTerm,V> Map<String,PrologTerm>[]	AbstractEngine.toTermMapArray(Map<String,V>[] map, Class<K> from)
<K extends PrologTerm,V> Map<String,PrologTerm>[]	AbstractConverter.toTermMapArray(Map<String,V>[] map, Class<K> from)
<K extends PrologTerm> K[][]	AbstractProvider.toTermMatrix(Object[][] oss, Class<K[][]> from)
<K extends PrologTerm> K[][]	AbstractConverter.toTermMatrix(Object[][] oss, Class<K[][]> from)

Methods in io.github.prolobjectlink.prolog that return PrologTerm

Modifier and Type	Method and Description
PrologTerm[][]	PrologQuery.allSolutions() Return a Prolog terms matrix of n x m order that conform the solution set for the current query where n is the solution number and m is a free variable number in the query.
PrologTerm	PrologProvider.falseReference() Create a prolog object reference term that hold the Java false object i.e.
PrologTerm	PrologTerm.getArgument(int index) Term located at some given index position in the current term arguments if current term is a compound term.
PrologTerm	PrologClause.getArgument(int index) Term located at some given index position in the clause head arguments.
PrologTerm	AbstractTerm.getArgument(int index)
PrologTerm	AbstractClause.getArgument(int index)
PrologTerm[]	PrologTerm.getArguments() Term arguments if the current term is a compound term.
PrologTerm[]	PrologClause.getArguments() Term arguments present in the clause head.
PrologTerm[]	AbstractClause.getArguments()
PrologTerm	PrologClause.getBody() Prolog term that represent the clause body.
PrologTerm	AbstractClause.getBody()
PrologTerm[]	PrologClause.getBodyArray() Get the clause body as terms array.
PrologTerm[]	AbstractClause.getBodyArray()
PrologTerm	PrologList.getHead() Return the head term of the current list if the current list have at least one element.
PrologTerm	PrologClause.getHead() Prolog term that represent the clause head.
PrologTerm	AbstractClause.getHead()
PrologTerm	PrologStructure.getLeft() Return the left operand of the current term if the current term is an evalueble structure (expression).
PrologTerm	PrologStructure.getRight() Return the right operand of the current term if the current term is an evalueble structure (expression).
PrologTerm	PrologList.getTail() Return the tail term of the current list if the current list have tail.
PrologTerm	PrologTerm.getTerm() Return current term instance if current term is not a variable or is a free variable term.
PrologTerm	PrologClause.getTerm() Prolog term representation of the current clause.
PrologTerm	AbstractTerm.getTerm()
PrologTerm	AbstractClause.getTerm()
PrologTerm	PrologProvider.newEntry(Object key, Object value) Create a new PrologEntry using key-value pair of Java object type.The given objects are converted to PrologTerm before entry creation.
PrologTerm	PrologProvider.newEntry(PrologTerm key, PrologTerm value) Create a new PrologEntry using key-value pair of PrologTerm type.
PrologTerm	PrologProvider.newMap() Constructs an empty PrologMap with the default initial capacity (16).
PrologTerm	PrologProvider.newMap(int initialCapacity) Constructs an empty PrologMap with the specified initial capacity.
PrologTerm	PrologProvider.newMap(Map<PrologTerm,PrologTerm> map) Constructs a new PrologMap with the same mappings as the specified Map of PrologTerm keys and values.
PrologTerm	PrologProvider.newReference(Object object) Create a prolog object reference term that hold the given object.
PrologTerm	PrologProvider.newStructure(Object left, String operator, Object right) Create a prolog structure that represent an expression defined by your left and right operands separated by infix operator.
PrologTerm	AbstractProvider.newStructure(Object left, String operator, Object right)
PrologTerm	PrologProvider.newStructure(PrologTerm left, String operator, PrologTerm right) Create a prolog structure that represent an expression defined by your left and right operands separated by infix operator.
PrologTerm	PrologProvider.newStructure(String functor, Object... arguments) Create a prolog structure with the functor (structure name) and java objects arguments array.
PrologTerm	AbstractProvider.newStructure(String functor, Object... arguments)
PrologTerm[]	PrologQuery.nextSolution() Return the next prolog terms solution array for the current query.
PrologTerm[][]	PrologQuery.nSolutions(int n) Return a Prolog terms matrix of n x m order that conform the solution set for the current query where n is the solution number and m is a free variable number in the query.
PrologTerm	PrologProvider.nullReference() Create a prolog object reference term that hold the Java null object i.e.
PrologTerm[]	PrologQuery.oneSolution() Return the prolog terms that conform the solution set for the current query.
PrologTerm	PrologProvider.prologCut() Get the prolog term that represent the prolog cut built-in.
PrologTerm	PrologProvider.prologEmpty() Get the prolog empty list term.
PrologTerm	PrologProvider.prologFail() Get the prolog fail term that represent fail built-in.
PrologTerm	PrologProvider.prologFalse() Get the prolog false term that represent false built-in.
PrologTerm	PrologProvider.prologInclude(String file) Get the prolog term representing the directive use by under-laying prolog implementation for file inclusion.
PrologTerm	PrologProvider.prologNil() Get the prolog nil term representing the null data type for prolog data type system.
PrologTerm	PrologProvider.prologTrue() Get the prolog true term that represent true built-in.
PrologTerm	PrologJavaConverter.toTerm(Object object) Create an equivalent Prolog term using the given Java object.
PrologTerm	AbstractJavaConverter.toTerm(Object object)
PrologTerm	PrologConverter.toTerm(T prologTerm) Create an equivalent Prolog term using the given native term representation.
protected <K extends PrologTerm> K[]	AbstractTerm.toTermArray(Object[] os, Class<K[]> from)
<K extends PrologTerm> K[]	AbstractProvider.toTermArray(Object[] os, Class<K[]> from)
<K extends PrologTerm> K[]	AbstractConverter.toTermArray(Object[] os, Class<K[]> from)
PrologTerm[]	PrologConverter.toTermArray(T[] terms) Create an equivalent Prolog terms array using the given native terms array representation.
PrologTerm[]	AbstractConverter.toTermArray(T[] terms)
<K extends PrologTerm> K[][]	AbstractProvider.toTermMatrix(Object[][] oss, Class<K[][]> from)
<K extends PrologTerm> K[][]	AbstractConverter.toTermMatrix(Object[][] oss, Class<K[][]> from)
PrologTerm[][]	PrologConverter.toTermMatrix(T[][] terms) Create an equivalent Prolog terms matrix using the given native terms matrix representation.
PrologTerm[][]	AbstractConverter.toTermMatrix(T[][] terms)
PrologTerm[]	PrologJavaConverter.toTermsArray(Object[] objects) Create an equivalent Prolog terms array using the given Java objects array.
PrologTerm[]	AbstractJavaConverter.toTermsArray(Object[] objects)
PrologTerm	PrologProvider.trueReference() Create a prolog object reference term that hold the Java true object i.e.
PrologTerm	PrologProvider.voidReference() Create a prolog object reference term that hold the Java void object i.e.

Methods in io.github.prolobjectlink.prolog that return types with arguments of type PrologTerm

Modifier and Type	Method and Description
List<Map<String,PrologTerm>>	PrologQuery.all() Return a list of map of variables name key and Prolog terms as value that conform the solution set for the current query.
Iterator<PrologTerm>	PrologClause.getBodyIterator() Iterator to iterate over all body terms.
Iterator<PrologTerm>	AbstractClause.getBodyIterator()
Iterator<Collection<PrologTerm>>	AbstractQuery.iterator()
Map<String,PrologTerm>	PrologTerm.match(PrologTerm term) Match to other term returning list of substitutions.
Map<String,PrologTerm>	AbstractTerm.match(PrologTerm term) Match to other term returning list of substitutions.
Map<String,PrologTerm>	PrologEngine.match(PrologTerm t1, PrologTerm t2) Match to other term returning list of substitutions.
Map<String,PrologTerm>	AbstractEngine.match(PrologTerm t1, PrologTerm t2)
Map<String,PrologTerm>	PrologQuery.more() Return the next prolog terms that conform the solution set for the current query.
Map<String,PrologTerm>	AbstractQuery.more()
Collection<PrologTerm>	AbstractQuery.next()
Map<String,PrologTerm>	PrologQuery.nextVariablesSolution() Return the next prolog terms that conform the solution set for the current query.
List<Map<String,PrologTerm>>	PrologQuery.nths(int n) Return a list of n size with maps of variables name key and Prolog terms as value that conform the solution set for the current query where n is the solution number.
List<Map<String,PrologTerm>>	AbstractQuery.nths(int n)
Map<String,PrologTerm>	PrologQuery.one() Return a map of variables name key and Prolog terms as value that conform the solution set for the current query.
Map<String,PrologTerm>	AbstractQuery.one()
Map<String,PrologTerm>	PrologQuery.oneVariablesSolution() Return the prolog terms that conform the solution set for the current query.
List<Map<String,PrologTerm>>	PrologEngine.queryAll(PrologTerm goal)
List<Map<String,PrologTerm>>	AbstractEngine.queryAll(PrologTerm goal)
List<Map<String,PrologTerm>>	PrologEngine.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>>	AbstractEngine.queryAll(PrologTerm goal, PrologTerm... goals)
List<Map<String,PrologTerm>>	PrologEngine.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>>	AbstractEngine.queryAll(String goal)
List<Map<String,PrologTerm>>	PrologEngine.queryN(int n, PrologTerm goal)
List<Map<String,PrologTerm>>	AbstractEngine.queryN(int n, PrologTerm term)
List<Map<String,PrologTerm>>	PrologEngine.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>>	AbstractEngine.queryN(int n, PrologTerm term, PrologTerm... terms)
List<Map<String,PrologTerm>>	PrologEngine.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.
List<Map<String,PrologTerm>>	AbstractEngine.queryN(int n, String goal)
Map<String,PrologTerm>	PrologEngine.queryOne(PrologTerm goal)
Map<String,PrologTerm>	AbstractEngine.queryOne(PrologTerm goal)
Map<String,PrologTerm>	PrologEngine.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>	AbstractEngine.queryOne(PrologTerm goal, PrologTerm... goals)
Map<String,PrologTerm>	PrologEngine.queryOne(String goal) Create a new prolog query and return the prolog terms that conform the solution set for the current query.
Map<String,PrologTerm>	AbstractEngine.queryOne(String goal)
Map<String,PrologTerm>	PrologConverter.toTermMap(Map<String,T> map) Create an equivalent Prolog terms map using the given native terms map representation.
Map<String,PrologTerm>	AbstractConverter.toTermMap(Map<String,T> map)
<K extends PrologTerm,V> Map<String,PrologTerm>	AbstractProvider.toTermMap(Map<String,V> map, Class<K> from)
<K extends PrologTerm,V> Map<String,PrologTerm>	AbstractConverter.toTermMap(Map<String,V> map, Class<K> from)

Methods in io.github.prolobjectlink.prolog with parameters of type PrologTerm

Modifier and Type	Method and Description
void	PrologEngine.asserta(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist.
void	PrologEngine.asserta(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
void	PrologEngine.asserta(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
void	PrologEngine.assertz(PrologTerm term) Create internal prolog clause and add the clause in the main memory program if the clause non exist.
void	PrologEngine.assertz(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
void	PrologEngine.assertz(PrologTerm head, PrologTerm... body) Add a rule specified by the rule head and rule body if the specified rule clause non exist.
PrologQueryBuilder	PrologQueryBuilder.begin(PrologTerm term) Append to the query builder the first term to be query.
PrologClauseBuilder	PrologClauseBuilder.begin(PrologTerm term) Append to the clause builder the head term in the clause.
PrologQueryBuilder	PrologQueryBuilder.begin(String functor, PrologTerm... arguments) Append to the query builder the first term to be query.
PrologClauseBuilder	PrologClauseBuilder.begin(String functor, PrologTerm... arguments) Append to the clause builder the head term in the clause.
<T extends PrologTerm> T	PrologProvider.cast(PrologTerm term) Casts a PrologTerm to the class or interface represented by this Class object.
protected <T extends PrologTerm> T	AbstractTerm.cast(PrologTerm term) Casts a PrologTerm to the class or interface represented by this Class object.
<T extends PrologTerm> T	AbstractProvider.cast(PrologTerm term)
protected <T extends PrologTerm> T	AbstractTerm.cast(PrologTerm term, Class<T> type) Casts a PrologTerm to the class or interface represented by this Class object.
protected <T extends PrologTerm> T	AbstractProvider.cast(PrologTerm term, Class<T> type) Casts a PrologTerm to the class or interface represented by this Class object.
boolean	PrologEngine.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	PrologEngine.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	PrologEngine.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.
PrologQueryBuilder	PrologQueryBuilder.comma(PrologTerm term) Append to the query builder other term to be query in conjunctive mode.
PrologClauseBuilder	PrologClauseBuilder.comma(PrologTerm term) Append to the clause builder other term in the clause body in conjunctive mode.
PrologQueryBuilder	PrologQueryBuilder.comma(PrologTerm left, String operator, PrologTerm right) Append to the query builder other term to be query in conjunctive mode.
PrologClauseBuilder	PrologClauseBuilder.comma(PrologTerm left, String operator, PrologTerm right) Append to the clause builder other term in the clause body in conjunctive mode.
PrologQueryBuilder	PrologQueryBuilder.comma(String functor, PrologTerm... arguments) Append to the query builder other term to be query in conjunctive mode.
PrologClauseBuilder	PrologClauseBuilder.comma(String functor, PrologTerm... arguments) Append to the clause builder other term in the clause body in conjunctive mode.
int	AbstractCompounds.compareTo(PrologTerm term)
protected boolean	AbstractQuery.contains(List<PrologTerm[]> arrays, PrologTerm[] array)
boolean	PrologEngine.contains(PrologTerm goal) Check if the given goal array have solution using the resolution engine mechanism.
boolean	AbstractEngine.contains(PrologTerm goal)
boolean	PrologEngine.contains(PrologTerm goal, PrologTerm... goals) Check if the given goal array have solution using the resolution engine mechanism.
boolean	PrologEngine.contains(PrologTerm goal, PrologTerm... goals) Check if the given goal array have solution using the resolution engine mechanism.
boolean	AbstractEngine.contains(PrologTerm goal, PrologTerm... goals)
boolean	AbstractEngine.contains(PrologTerm goal, PrologTerm... goals)
T	PrologConverter.fromTerm(PrologTerm term) Create a native term representation from given Prolog term.
protected <K> K	AbstractTerm.fromTerm(PrologTerm term, Class<K> to)
protected <K> K	AbstractQuery.fromTerm(PrologTerm term, Class<K> to)
<K> K	AbstractProvider.fromTerm(PrologTerm term, Class<K> to)
protected <K> K	AbstractEngine.fromTerm(PrologTerm term, Class<K> to)
<K> K	AbstractConverter.fromTerm(PrologTerm term, Class<K> to)
T	PrologConverter.fromTerm(PrologTerm head, PrologTerm[] body) Create a native rule representation term from given head and body.
T	PrologConverter.fromTerm(PrologTerm head, PrologTerm[] body) Create a native rule representation term from given head and body.
<K> K	AbstractProvider.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
<K> K	AbstractProvider.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
protected <K> K	AbstractEngine.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
protected <K> K	AbstractEngine.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
<K> K	AbstractConverter.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
<K> K	AbstractConverter.fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to)
T[]	PrologConverter.fromTermArray(PrologTerm[] terms) Create a native term array representation from given Prolog term array.
protected <K> K[]	AbstractTerm.fromTermArray(PrologTerm[] terms, Class<K[]> to)
<K> K[]	AbstractProvider.fromTermArray(PrologTerm[] terms, Class<K[]> to)
<K> K[]	AbstractConverter.fromTermArray(PrologTerm[] terms, Class<K[]> to)
Map<String,PrologTerm>	PrologTerm.match(PrologTerm term) Match to other term returning list of substitutions.
Map<String,PrologTerm>	AbstractTerm.match(PrologTerm term) Match to other term returning list of substitutions.
Map<String,PrologTerm>	PrologEngine.match(PrologTerm t1, PrologTerm t2) Match to other term returning list of substitutions.
Map<String,PrologTerm>	AbstractEngine.match(PrologTerm t1, PrologTerm t2)
PrologClauseBuilder	PrologClauseBuilder.neck(PrologTerm term) Append to the clause builder the first term in the clause body.
PrologClauseBuilder	PrologClauseBuilder.neck(PrologTerm left, String operator, PrologTerm right) Append to the clause builder the first term in the clause body.
PrologClauseBuilder	PrologClauseBuilder.neck(String functor, PrologTerm... arguments) Append to the clause builder the first term in the clause body.
PrologTerm	PrologProvider.newEntry(PrologTerm key, PrologTerm value) Create a new PrologEntry using key-value pair of PrologTerm type.
PrologList	PrologProvider.newList(PrologTerm head) Create a prolog list with one term item.
PrologList	AbstractProvider.newList(PrologTerm head)
PrologList	PrologProvider.newList(PrologTerm[] arguments) Create a prolog list from prolog terms arguments array and the tail item is an empty list.
PrologList	PrologProvider.newList(PrologTerm[] arguments, PrologTerm tail) Create a prolog list from prolog terms arguments array and the tail item is the given prolog term.
PrologList	PrologProvider.newList(PrologTerm[] arguments, PrologTerm tail) Create a prolog list from prolog terms arguments array and the tail item is the given prolog term.
PrologList	PrologProvider.newList(PrologTerm head, PrologTerm tail) Create a prolog list with two terms items [head | tail].
PrologTerm	PrologProvider.newStructure(PrologTerm left, String operator, PrologTerm right) Create a prolog structure that represent an expression defined by your left and right operands separated by infix operator.
PrologStructure	PrologProvider.newStructure(String functor, PrologTerm... arguments) Create a prolog structure with the functor (structure name) and prolog terms arguments array.
PrologQuery	PrologEngine.query(PrologTerm goal)
PrologQuery	PrologEngine.query(PrologTerm[] terms) Create a new query being the goal the given prolog term array.
PrologQuery	PrologEngine.query(PrologTerm term, PrologTerm... terms) Create a new query with at least one prolog term goal.
PrologQuery	PrologEngine.query(PrologTerm term, PrologTerm... terms) Create a new query with at least one prolog term goal.
List<Map<String,PrologTerm>>	PrologEngine.queryAll(PrologTerm goal)
List<Map<String,PrologTerm>>	AbstractEngine.queryAll(PrologTerm goal)
List<Map<String,PrologTerm>>	PrologEngine.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>>	PrologEngine.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>>	AbstractEngine.queryAll(PrologTerm goal, PrologTerm... goals)
List<Map<String,PrologTerm>>	AbstractEngine.queryAll(PrologTerm goal, PrologTerm... goals)
List<Map<String,PrologTerm>>	PrologEngine.queryN(int n, PrologTerm goal)
List<Map<String,PrologTerm>>	AbstractEngine.queryN(int n, PrologTerm term)
List<Map<String,PrologTerm>>	PrologEngine.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>>	PrologEngine.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>>	AbstractEngine.queryN(int n, PrologTerm term, PrologTerm... terms)
List<Map<String,PrologTerm>>	AbstractEngine.queryN(int n, PrologTerm term, PrologTerm... terms)
Map<String,PrologTerm>	PrologEngine.queryOne(PrologTerm goal)
Map<String,PrologTerm>	AbstractEngine.queryOne(PrologTerm goal)
Map<String,PrologTerm>	PrologEngine.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>	PrologEngine.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>	AbstractEngine.queryOne(PrologTerm goal, PrologTerm... goals)
Map<String,PrologTerm>	AbstractEngine.queryOne(PrologTerm goal, PrologTerm... goals)
void	PrologEngine.retract(PrologTerm term) Remove a fact specified by the head if the specified fact clause exist.
void	PrologEngine.retract(PrologTerm head, PrologTerm... body) Remove a rule specified by the rule head and rule body if the specified rule clause exist.
void	PrologEngine.retract(PrologTerm head, PrologTerm... body) Remove a rule specified by the rule head and rule body if the specified rule clause exist.
PrologQueryBuilder	PrologQueryBuilder.semicolon(PrologTerm term) Append to the query builder other term to be query in disjunctive mode.
PrologQueryBuilder	PrologQueryBuilder.semicolon(PrologTerm left, String operator, PrologTerm right) Append to the query builder other term to be query in disjunctive mode.
PrologQueryBuilder	PrologQueryBuilder.semicolon(String functor, PrologTerm... arguments) Append to the query builder other term to be query in disjunctive mode.
Object	PrologJavaConverter.toObject(PrologTerm term) Create a Java object from given Prolog term.
Object	AbstractJavaConverter.toObject(PrologTerm prologTerm)
List<Object>	PrologJavaConverter.toObjectList(PrologTerm[] terms) Create a Java objects list from given Prolog term array.
List<Object>	AbstractJavaConverter.toObjectList(PrologTerm[] terms)
List<List<Object>>	PrologJavaConverter.toObjectLists(PrologTerm[][] terms) Create an equivalent list of objects lists using the given Prolog terms matrix.
List<List<Object>>	AbstractJavaConverter.toObjectLists(PrologTerm[][] terms)
Object[]	PrologJavaConverter.toObjectsArray(PrologTerm[] terms) Create a Java objects array from given Prolog term array.
Object[]	AbstractJavaConverter.toObjectsArray(PrologTerm[] terms)
boolean	PrologTerm.unify(PrologTerm term) Check that the current term unify with the given term.
boolean	AbstractCompounds.unify(PrologTerm term)
boolean	PrologEngine.unify(PrologTerm t1, PrologTerm t2) Check that two terms (x and y) unify.
boolean	AbstractEngine.unify(PrologTerm t1, PrologTerm t2)

Method parameters in io.github.prolobjectlink.prolog with type arguments of type PrologTerm

Modifier and Type	Method and Description
protected boolean	AbstractQuery.contains(List<Map<String,PrologTerm>> maps, Map<String,PrologTerm> map)
protected boolean	AbstractQuery.contains(List<Map<String,PrologTerm>> maps, Map<String,PrologTerm> map)
boolean	PrologMap.contains(Map.Entry<PrologTerm,PrologTerm> entry) True if this map contains an entry previously created
boolean	PrologMap.contains(Map.Entry<PrologTerm,PrologTerm> entry) True if this map contains an entry previously created
PrologTerm	PrologProvider.newMap(Map<PrologTerm,PrologTerm> map) Constructs a new PrologMap with the same mappings as the specified Map of PrologTerm keys and values.
PrologTerm	PrologProvider.newMap(Map<PrologTerm,PrologTerm> map) Constructs a new PrologMap with the same mappings as the specified Map of PrologTerm keys and values.
void	PrologMap.put(Map.Entry<PrologTerm,PrologTerm> entry) Put in the map an entry previously created
void	PrologMap.put(Map.Entry<PrologTerm,PrologTerm> entry) Put in the map an entry previously created
void	PrologMap.putAll(Collection<Map.Entry<PrologTerm,PrologTerm>> entries) Put all collections of entries in the map.
void	PrologMap.putAll(Collection<Map.Entry<PrologTerm,PrologTerm>> entries) Put all collections of entries in the map.
void	PrologMap.remove(Map.Entry<PrologTerm,PrologTerm> entry) Remove in the map an entry previously created
void	PrologMap.remove(Map.Entry<PrologTerm,PrologTerm> entry) Remove in the map an entry previously created
Map<String,Object>	PrologJavaConverter.toObjectMap(Map<String,PrologTerm> map) Create an equivalent Java object map using the given Prolog terms map.
Map<String,Object>	AbstractJavaConverter.toObjectMap(Map<String,PrologTerm> map)

Constructors in io.github.prolobjectlink.prolog with parameters of type PrologTerm

Constructor and Description
AbstractClause(PrologProvider provider, PrologTerm head, boolean dynamic, boolean multifile, boolean discontiguous) Create a new fact clause.
AbstractClause(PrologProvider provider, PrologTerm head, PrologTerm body, boolean dynamic, boolean multifile, boolean discontiguous) Create a new rule clause.