io.github.prolobjectlink.prolog

Interface PrologProvider

All Known Implementing Classes:

AbstractProvider

public interface PrologProvider

Prolog Provider is the class to interact with all prolog components (data types, constants, logger, parser, converter and engine). Allow create data types like atoms, numbers, lists, structures and variable terms. Allow interact with the under-lying prolog engine to realize inferences operations. Other used components are the prolog parser to parse prolog terms in string form. The Prolog Provider offer a prolog system logger to report every errors or exceptions.

Since:

1.0

Author:

Jose Zalacain

Method Summary

Modifier and Type	Method and Description
<T extends PrologTerm> T	cast(PrologTerm term) Casts a PrologTerm to the class or interface represented by this Class object.
PrologTerm	falseReference() Create a prolog object reference term that hold the Java false object i.e.
<K> K	fromTerm(PrologTerm term, Class<K> to) Create a native rule representation term from given head and body and cast this native term to some specific given class.
<K> K	fromTerm(PrologTerm head, PrologTerm[] body, Class<K> to) Create a native rule representation term from given head and body and cast this native term to some specific given class.
<K> K[]	fromTermArray(PrologTerm[] terms, Class<K[]> to) Create a native term array representation from given Prolog term array and cast this native term array to some specific given array class.
<K> PrologConverter<K>	getConverter() Get a prolog converter instance to map the abstract prolog data types to under-laying prolog implementations data types.
PrologJavaConverter	getJavaConverter() Get a Java to Prolog converter instance to map the abstract prolog data types to Java types.
PrologLogger	getLogger() Get the prolog system logger instance to report any errors or exceptions
String	getName() Name of the wrapped engine.
io.github.prolobjectlink.prolog.PrologParser	getParser() Get a prolog parser instance to parser the strings with prolog syntax.
String	getVersion() Version of the wrapped engine.
boolean	isCompliant() True if wrapped engine implement ISO Prolog and false in other case
PrologAtom	newAtom(String functor) Create a prolog atom term setting like atom value the given string.
PrologDouble	newDouble() Create a prolog double number instance with 0.0 value.
PrologDouble	newDouble(Number value) Create a prolog double number instance with the given value.
PrologEngine	newEngine() Create a new prolog engine instance ready to be operate.
PrologEngine	newEngine(String file) Create a new prolog engine instance ready to be operate.
PrologTerm	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	newEntry(PrologTerm key, PrologTerm value) Create a new PrologEntry using key-value pair of PrologTerm type.
PrologFloat	newFloat() Create a prolog float number instance with 0.0 value.
PrologFloat	newFloat(Number value) Create a prolog float number instance with 0.0 value.
PrologInteger	newInteger() Create a prolog integer number instance with 0 value.
PrologInteger	newInteger(Number value) Create a prolog integer number instance with the given value.
PrologList	newList() Create an empty prolog list term.
PrologList	newList(Object head) Create a prolog list with one object item.
PrologList	newList(Object[] arguments) Create a prolog list from java objects arguments array and the tail item is an empty list.
PrologList	newList(Object[] arguments, Object tail) Create a prolog list from java objects arguments array and the tail item is the given java object.
PrologList	newList(Object head, Object tail) Create a prolog list with two java objects items [head | tail].
PrologList	newList(PrologTerm head) Create a prolog list with one term item.
PrologList	newList(PrologTerm[] arguments) Create a prolog list from prolog terms arguments array and the tail item is an empty list.
PrologList	newList(PrologTerm[] arguments, PrologTerm tail) Create a prolog list from prolog terms arguments array and the tail item is the given prolog term.
PrologList	newList(PrologTerm head, PrologTerm tail) Create a prolog list with two terms items [head | tail].
PrologLong	newLong() Create a prolog long number instance with 0 value.
PrologLong	newLong(Number value) Create a prolog long number instance with the given value.
PrologTerm	newMap() Constructs an empty PrologMap with the default initial capacity (16).
PrologTerm	newMap(int initialCapacity) Constructs an empty PrologMap with the specified initial capacity.
PrologTerm	newMap(Map<PrologTerm,PrologTerm> map) Constructs a new PrologMap with the same mappings as the specified Map of PrologTerm keys and values.
PrologTerm	newReference(Object object) Create a prolog object reference term that hold the given object.
PrologTerm	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	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	newStructure(String functor, Object... arguments) Create a prolog structure with the functor (structure name) and java objects arguments array.
PrologStructure	newStructure(String functor, PrologTerm... arguments) Create a prolog structure with the functor (structure name) and prolog terms arguments array.
PrologVariable	newVariable(int position) Create an anonymous variable instance with associated index.
PrologVariable	newVariable(String name, int position) Create an named variable instance with associated index.
PrologTerm	nullReference() Create a prolog object reference term that hold the Java null object i.e.
PrologClause	parseClause(String clause) Parse the string with Prolog syntax and create an equivalent Prolog clause instance.
PrologList	parseList(String stringList) Parse the string with Prolog syntax and create an equivalent Prolog list term instance.
Set<PrologClause>	parseProgram(File in) Parse the Prolog text contained at specific file and return a Prolog clause set found in the file.
Set<PrologClause>	parseProgram(String file) Parse the Prolog text contained at specific file path and return a Prolog clause set found in the file.
PrologStructure	parseStructure(String stringStructure) Parse the string with Prolog syntax and create an equivalent Prolog structure term instance.
PrologTerm	parseTerm(String term) Parse the string with Prolog syntax and create an equivalent Prolog term instance.
PrologTerm[]	parseTerms(String stringTerms) Parse the comma separate terms in the given string with prolog syntax and return an array of terms formed by the comma separate terms.
PrologTerm	prologCut() Get the prolog term that represent the prolog cut built-in.
PrologTerm	prologEmpty() Get the prolog empty list term.
PrologTerm	prologFail() Get the prolog fail term that represent fail built-in.
PrologTerm	prologFalse() Get the prolog false term that represent false built-in.
PrologTerm	prologInclude(String file) Get the prolog term representing the directive use by under-laying prolog implementation for file inclusion.
PrologTerm	prologNil() Get the prolog nil term representing the null data type for prolog data type system.
PrologTerm	prologTrue() Get the prolog true term that represent true built-in.
<K extends PrologTerm> K	toTerm(Object o, Class<K> from) Create an equivalent Prolog term using the given native term representation and cast this Prolog term to some specific given class.
<K extends PrologTerm> K[]	toTermArray(Object[] objects, Class<K[]> from) Create an equivalent Prolog terms array using the given native terms array representation and cast this Prolog term array to some specific array component class.
<K extends PrologTerm,V> Map<String,PrologTerm>	toTermMap(Map<String,V> map, Class<K> from) Create an equivalent Prolog terms map using the given native terms map representation and cast every Prolog term to some specific given class.
<K extends PrologTerm,V> Map<String,PrologTerm>[]	toTermMapArray(Map<String,V>[] map, Class<K> from) Create an equivalent Prolog terms map array using the given native terms map array representation and cast every Prolog term to some specific given class.
<K extends PrologTerm> K[][]	toTermMatrix(Object[][] objects, Class<K[][]> from) Create an equivalent Prolog terms matrix using the given native terms matrix representation and cast every Prolog terms matrix to some specific matrix component class.
PrologTerm	trueReference() Create a prolog object reference term that hold the Java true object i.e.
PrologTerm	voidReference() Create a prolog object reference term that hold the Java void object i.e.

Method Detail

isCompliant

boolean isCompliant()

True if wrapped engine implement ISO Prolog and false in other case

Returns:

true if wrapped engine implement ISO Prolog and false in other case

Since:

1.0

prologNil

PrologTerm prologNil()

Get the prolog nil term representing the null data type for prolog data type system.

Returns:

prolog nil term.

Since:

1.0

prologCut

PrologTerm prologCut()

Get the prolog term that represent the prolog cut built-in.

Returns:

prolog cut term

Since:

1.0

prologFail

PrologTerm prologFail()

Get the prolog fail term that represent fail built-in.

Returns:

prolog fail term

Since:

1.0

prologTrue

PrologTerm prologTrue()

Get the prolog true term that represent true built-in.

Returns:

prolog true term

Since:

1.0

prologFalse

PrologTerm prologFalse()

Get the prolog false term that represent false built-in.

Returns:

prolog false term

Since:

1.0

prologEmpty

PrologTerm prologEmpty()

Get the prolog empty list term.

Returns:

prolog empty list term.

Since:

1.0

prologInclude

PrologTerm prologInclude(String file)

Get the prolog term representing the directive use by under-laying prolog implementation for file inclusion. This directive is implementation depending. Prolog engines use at least one of (include/1 or consult/1 or ensure_loaded/1). A string file path is used to create the directive with the file to be include at runtime. In other words invoke this method for foo.pl return :-consult('foo.pl') prolog term if the under-laying prolog implementation use consult/1 directive for file inclusion.

Parameters:

file - file path to be include

Returns:

prolog term representing include directive

Since:

1.0

newEngine

PrologEngine newEngine()

Create a new prolog engine instance ready to be operate. The created engine is clause empty and only have the defaults supported built-ins.

Returns:

new prolog engine instance

Since:

1.0

newEngine

PrologEngine newEngine(String file)

Create a new prolog engine instance ready to be operate. The created engine consult the given file loading the clauses present in this file and the defaults supported built-ins. Is equivalent to newEngine().consult(file);

Parameters:

file - file path to be consulted

Returns:

new prolog engine instance

Since:

1.0

newAtom

PrologAtom newAtom(String functor)

Create a prolog atom term setting like atom value the given string.

Parameters:

functor - string value for the atom

Returns:

a prolog atom term

Since:

1.0

newFloat

PrologFloat newFloat()

Create a prolog float number instance with 0.0 value.

Returns:

prolog float number with 0.0 value.

Since:

1.0

newFloat

PrologFloat newFloat(Number value)

Create a prolog float number instance with 0.0 value.

Parameters:

value - numeric value

Returns:

prolog float number with 0.0 value.

Since:

1.0

newDouble

PrologDouble newDouble()

Create a prolog double number instance with 0.0 value.

Returns:

prolog double number with 0.0 value.

Since:

1.0

newDouble

PrologDouble newDouble(Number value)

Create a prolog double number instance with the given value.

Parameters:

value - numeric value

Returns:

prolog double number

Since:

1.0

newInteger

PrologInteger newInteger()

Create a prolog integer number instance with 0 value.

Returns:

prolog integer number with 0 value.

Since:

1.0

newInteger

PrologInteger newInteger(Number value)

Create a prolog integer number instance with the given value.

Parameters:

value - numeric value

Returns:

prolog integer number

Since:

1.0

newLong

PrologLong newLong()

Create a prolog long number instance with 0 value.

Returns:

prolog long number with 0 value.

Since:

1.0

newLong

PrologLong newLong(Number value)

Create a prolog long number instance with the given value.

Parameters:

value - numeric value

Returns:

prolog long number

Since:

1.0

newVariable

PrologVariable newVariable(int position)

Create an anonymous variable instance with associated index. Index is a non negative integer that represent the variable position of the Structure where the variable is first time declared.

Parameters:

position - Position of its Structure where the variable is first time declared.

Returns:

An anonymous variable instance with associated index.

Throws:

IllegalArgumentException - if position is a negative number

Since:

1.0

newVariable

PrologVariable newVariable(String name,
                           int position)

Create an named variable instance with associated index. Index is a non negative integer that represent the variable position of the Structure where the variable is first time declared.

Parameters:

name - variable name (upper case beginning)

position - Position of its Structure where the variable is first time declared.

Returns:

A named variable instance with associated index.

Throws:

IllegalArgumentException - if position is a negative number

Since:

1.0

newList

PrologList newList()

Create an empty prolog list term. The created prolog list is equivalent to empty list term if the returned instance is not the prolog empty list itself.

Returns:

an empty prolog list term

Since:

1.0

newList

PrologList newList(PrologTerm head)

Create a prolog list with one term item.

Parameters:

head - term item to be include in the prolog list

Returns:

prolog list with one term item.

Since:

1.0

newList

PrologList newList(PrologTerm[] arguments)

Create a prolog list from prolog terms arguments array and the tail item is an empty list.

Parameters:

arguments - prolog terms arguments array.

Returns:

a prolog list contained all terms in the prolog term array.

Since:

1.0

newList

PrologList newList(PrologTerm head,
                   PrologTerm tail)

Create a prolog list with two terms items [head | tail].

Parameters:

head - term item to be include like head in the prolog list.

tail - term item to be include like tail in the prolog list.

Returns:

prolog list with two terms items [head | tail].

Since:

1.0

newList

PrologList newList(PrologTerm[] arguments,
                   PrologTerm tail)

Create a prolog list from prolog terms arguments array and the tail item is the given prolog term.

Parameters:

arguments - prolog terms arguments array.

tail - prolog term to be the tail item.

Returns:

a prolog list contained all terms in the prolog term array and tail item the specific term.

Since:

1.0

newList

PrologList newList(Object head)

Create a prolog list with one object item.

Parameters:

head - object item to be include in the prolog list

Returns:

prolog list with one term item.

Since:

1.0

newList

PrologList newList(Object[] arguments)

Create a prolog list from java objects arguments array and the tail item is an empty list.

Parameters:

arguments - java objects arguments array.

Returns:

a prolog list contained all terms in the prolog term array.

Since:

1.0

newList

PrologList newList(Object head,
                   Object tail)

Create a prolog list with two java objects items [head | tail].

Parameters:

head - object item to be include like head in the prolog list.

tail - object item to be include like tail in the prolog list.

Returns:

prolog list with two terms items [head | tail].

Since:

1.0

newList

PrologList newList(Object[] arguments,
                   Object tail)

Create a prolog list from java objects arguments array and the tail item is the given java object.

Parameters:

arguments - java objects arguments array.

tail - java object to be the tail item.

Returns:

a prolog list contained all terms in the prolog term array and tail item the specific term.

Since:

1.0

newStructure

PrologStructure newStructure(String functor,
                             PrologTerm... arguments)

Create a prolog structure with the functor (structure name) and prolog terms arguments array.

 PrologAtom bob = provider.newAtom("bob");
 PrologAtom tom = provider.newAtom("tom");
 PrologStructure parent = provider.newStructure("parent", tom, bob);
 System.out.println(parent);
 

Parameters:

functor - structure name.

arguments - prolog terms arguments array.

Returns:

prolog structure instance with the given functor and arguments.

Since:

1.0

newStructure

PrologTerm newStructure(String functor,
                        Object... arguments)

Create a prolog structure with the functor (structure name) and java objects arguments array. The java objects arguments array is converter to prolog terms arguments array.

 PrologStructure parent = provider.newStructure("parent", "tom", "bob");
 System.out.println(parent);
 

Parameters:

functor - structure name.

arguments - java objects arguments array.

Returns:

prolog structure instance with the given functor and arguments.

Since:

1.0

newStructure

PrologTerm 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. The structure instance have like functor the expression operator and have two operands arguments terms. In other words the indicator for the resulting instance term is operator/2. The term creation not check operator definition and for this reason during inference process if the operator is not a supported built-in or define by op/3 the inference fail.

 PrologVariable x = provider.newVariable("X", 0);
 PrologDouble pi = provider.newDouble(Math.PI);
 PrologStructure plusExp = provider.newStructure(x, "+", pi);
 System.out.println(plusExp);
 

Parameters:

left - left hand operand

operator - infix operand

right - right hand operand

Returns:

a prolog structure that represent an expression

Since:

1.0

newStructure

PrologTerm 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. The structure instance have like functor the expression operator and have two operands arguments terms. In other words the indicator for the resulting instance term is operator/2. The term creation not check operator definition and for this reason during inference process if the operator is not a supported built-in or define by op/3 the inference fail.

 PrologVariable x = provider.newVariable("X", 0);
 PrologDouble pi = provider.newDouble(Math.PI);
 PrologStructure plusExp = provider.newStructure(x, "+", pi);
 System.out.println(plusExp);
 

Parameters:

left - left hand operand

operator - infix operand

right - right hand operand

Returns:

a prolog structure that represent an expression

Since:

1.0

newMap

PrologTerm newMap(Map<PrologTerm,PrologTerm> map)

Constructs a new PrologMap with the same mappings as the specified Map of PrologTerm keys and values. The PrologMap is created with an initial capacity sufficient to hold the mappings in the specified Map. The resulting term is an implementation of Map and PrologTerm.

Parameters:

map - the map whose mappings are to be placed in this map

Returns:

a PrologMap with the given maps entries.

Since:

1.1

newEntry

PrologTerm newEntry(PrologTerm key,
                    PrologTerm value)

Create a new PrologEntry using key-value pair of PrologTerm type. The resulting term is an implementation of PrologEntry and PrologTerm.

Parameters:

key - key of the entry

value - value of the entry

Returns:

new PrologEntry term

Since:

1.1

newEntry

PrologTerm 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. The resulting term is an implementation of PrologEntry and PrologTerm.

Parameters:

key - key of the entry

value - value of the entry

Returns:

new PrologEntry term

Since:

1.1

newMap

PrologTerm newMap(int initialCapacity)

Constructs an empty PrologMap with the specified initial capacity. The resulting term is an implementation of Map and PrologTerm.

Parameters:

initialCapacity - the initial capacity.

Returns:

an empty PrologMap

Since:

1.1

newMap

PrologTerm newMap()

Constructs an empty PrologMap with the default initial capacity (16). The resulting term is an implementation of Map and PrologTerm.

Returns:

an empty PrologMap

Since:

1.1

newReference

PrologTerm newReference(Object object)

Create a prolog object reference term that hold the given object. This reference term is equivalent on JPL JRef. This term is like a structure compound term that have like argument the object identification atom. The functor is the @ character and the arity is 1. An example of this prolog term is e.g @(J#00000000000000425). To access to the referenced object we need use PrologTerm.getObject().

Parameters:

object - object to be referenced

Returns:

a prolog object reference term

Since:

1.0

falseReference

PrologTerm falseReference()

Create a prolog object reference term that hold the Java false object i.e. @(false). This reference term is equivalent on JPL JFALSE.

Returns:

a prolog object reference term that hold the Java false object.

Since:

1.1

trueReference

PrologTerm trueReference()

Create a prolog object reference term that hold the Java true object i.e. @(true). This reference term is equivalent on JPL JTRUE.

Returns:

a prolog object reference term that hold the Java true object.

Since:

1.1

nullReference

PrologTerm nullReference()

Create a prolog object reference term that hold the Java null object i.e. @(null). This reference term is equivalent on JPL JNULL.

Returns:

a prolog object reference term that hold the Java null object.

Since:

1.1

voidReference

PrologTerm voidReference()

Create a prolog object reference term that hold the Java void object i.e. @(void). This reference term is equivalent on JPL JVOID.

Returns:

a prolog object reference term that hold the Java void object.

Since:

1.1

cast

<T extends PrologTerm> T cast(PrologTerm term)

Casts a PrologTerm to the class or interface represented by this Class object.

Parameters:

term - the object to be cast

Returns:

the PrologTerm after casting, or null if term is null

Throws:

ClassCastException - if the object is not null and is not assignable to the type T.

Since:

1.1

getJavaConverter

PrologJavaConverter getJavaConverter()

Get a Java to Prolog converter instance to map the abstract prolog data types to Java types.

Returns:

Java to Prolog converter instance.

Since:

1.0

getConverter

<K> PrologConverter<K> getConverter()

Get a prolog converter instance to map the abstract prolog data types to under-laying prolog implementations data types.

Type Parameters:

K - under-laying prolog data types

Returns:

prolog converter instance

Since:

1.0

getParser

io.github.prolobjectlink.prolog.PrologParser getParser()

Get a prolog parser instance to parser the strings with prolog syntax.

Returns:

prolog parser 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

getVersion

String getVersion()

Version of the wrapped engine.

Returns:

String version of the wrapped engine.

Since:

1.0

getName

String getName()

Name of the wrapped engine.

Returns:

String name of the wrapped engine.

Since:

1.0

parseTerm

PrologTerm parseTerm(String term)

Parse the string with Prolog syntax and create an equivalent Prolog term instance.

Parameters:

term - prolog term in string format.

Returns:

a Prolog term from prolog text

Since:

1.0

parseTerms

PrologTerm[] parseTerms(String stringTerms)

Parse the comma separate terms in the given string with prolog syntax and return an array of terms formed by the comma separate terms.

Parameters:

stringTerms - comma separate terms with prolog syntax

Returns:

an array of terms formed by the comma separate terms.

Since:

1.0

parseList

PrologList parseList(String stringList)

Parse the string with Prolog syntax and create an equivalent Prolog list term instance.

Parameters:

stringList - prolog term in string format.

Returns:

a Prolog term from prolog text.

Since:

1.0

parseStructure

PrologStructure parseStructure(String stringStructure)

Parse the string with Prolog syntax and create an equivalent Prolog structure term instance.

Parameters:

stringStructure - prolog term in string format.

Returns:

a Prolog term from prolog text.

Since:

1.0

parseClause

PrologClause parseClause(String clause)

Parse the string with Prolog syntax and create an equivalent Prolog clause instance.

Parameters:

clause - prolog clause in string format.

Returns:

a Prolog clause from prolog text.

Since:

1.0

parseProgram

Set<PrologClause> parseProgram(String file)

Parse the Prolog text contained at specific file path and return a Prolog clause set found in the file.

Parameters:

file - file path to be parsed.

Returns:

a Prolog clause set found in the file.

Since:

1.0

parseProgram

Set<PrologClause> parseProgram(File in)

Parse the Prolog text contained at specific file and return a Prolog clause set found in the file.

Parameters:

in - file to be parsed.

Returns:

a Prolog clause set found in the file.

Since:

1.0

toTermMapArray

<K extends PrologTerm,V> Map<String,PrologTerm>[] toTermMapArray(Map<String,V>[] map,
                                                                 Class<K> from)

Create an equivalent Prolog terms map array using the given native terms map array representation and cast every Prolog term to some specific given class. The resulting map array contains map that have the same string key and the value for every key is a conversion from native term to Prolog term.

Type Parameters:

K - generic type that extends from PrologTerm

V - generic type that extends from Object representing a native prolog term.

Parameters:

map - native terms map array to be converted in Prolog terms map array.

from - class to be cast the result Prolog term

Returns:

an equivalent Prolog terms map array using the given native terms map array representation of given class type.

Since:

1.0

toTermMap

<K extends PrologTerm,V> Map<String,PrologTerm> toTermMap(Map<String,V> map,
                                                          Class<K> from)

Create an equivalent Prolog terms map using the given native terms map representation and cast every Prolog term to some specific given class. The resulting map have the same string key and the value for every key is a conversion from native term to Prolog term.

Type Parameters:

K - generic type that extends from PrologTerm

V - generic type that extends from Object representing a native prolog term.

Parameters:

map - native terms map representation to be converted

from - class to be cast the result Prolog term

Returns:

an equivalent Prolog terms map using the given native terms map representation of given class type.

Since:

1.0

toTermMatrix

<K extends PrologTerm> K[][] toTermMatrix(Object[][] objects,
                                          Class<K[][]> from)

Create an equivalent Prolog terms matrix using the given native terms matrix representation and cast every Prolog terms matrix to some specific matrix component class.

Type Parameters:

K - generic type that extends from PrologTerm

Parameters:

objects - native terms matrix representation to be converted

from - class to be cast the result Prolog term

Returns:

an equivalent Prolog terms matrix using the given native terms matrix representation of array component class type.

Since:

1.0

toTermArray

<K extends PrologTerm> K[] toTermArray(Object[] objects,
                                       Class<K[]> from)

Create an equivalent Prolog terms array using the given native terms array representation and cast this Prolog term array to some specific array component class.

Type Parameters:

K - generic type that extends from PrologTerm

Parameters:

objects - native terms array representation to be converted

from - class to be cast the result Prolog term

Returns:

an equivalent Prolog terms array using the given native terms array representation of array component class type.

Since:

1.0

toTerm

<K extends PrologTerm> K toTerm(Object o,
                                Class<K> from)

Create an equivalent Prolog term using the given native term representation and cast this Prolog term to some specific given class.

Type Parameters:

K - generic type that extends from PrologTerm

Parameters:

o - native term representation to be converted

from - class to be cast the result Prolog term

Returns:

an equivalent Prolog term using the given native term representation of given class type.

Since:

1.0

fromTerm

<K> K fromTerm(PrologTerm term,
               Class<K> to)

Create a native rule representation term from given head and body and cast this native term to some specific given class.

Type Parameters:

K - generic type that represent native prolog type

Parameters:

term - Prolog term to be converted to native term.

to - class to be cast the result native term

Returns:

rule representation from given head and body of given class type.

Since:

1.0

fromTermArray

<K> K[] fromTermArray(PrologTerm[] terms,
                      Class<K[]> to)

Create a native term array representation from given Prolog term array and cast this native term array to some specific given array class.

Type Parameters:

K - generic type that represent native prolog type

Parameters:

terms - Prolog term array to be converted to native array.

to - class to be cast the result native term

Returns:

native term array representation from given Prolog term array of given array class type.

Since:

1.0

fromTerm

<K> K fromTerm(PrologTerm head,
               PrologTerm[] body,
               Class<K> to)

Create a native rule representation term from given head and body and cast this native term to some specific given class.

Type Parameters:

K - generic type that represent native prolog type

Parameters:

head - rule head

body - rule body

to - class to be cast the result native term

Returns:

rule representation from given head and body of given class type.

Since:

1.0