io.github.prolobjectlink.prolog

Interface PrologConverter<T>

Type Parameters:

T - native Term Representation

All Known Implementing Classes:

AbstractConverter

public interface PrologConverter<T>

Converter for convert PrologTerm to the equivalent native T term representation.

Since:

1.0

Author:

Jose Zalacain

Method Summary

Modifier and Type	Method and Description
PrologProvider	createProvider() Create a Prolog provider instance.
T	fromTerm(PrologTerm term) Create a native term representation from given Prolog term.
<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.
T	fromTerm(PrologTerm head, PrologTerm[] body) Create a native rule representation term from given head and body.
<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.
T[]	fromTermArray(PrologTerm[] terms) Create a native term array representation from given Prolog term array.
<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.
Class<T>	getGenericClass() Get the generic class for the current Prolog converter at runtime.
<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.
PrologTerm	toTerm(T prologTerm) Create an equivalent Prolog term using the given native term representation.
<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.
PrologTerm[]	toTermArray(T[] terms) Create an equivalent Prolog terms array using the given native terms array representation.
Map<String,PrologTerm>	toTermMap(Map<String,T> map) Create an equivalent Prolog terms map using the given native terms map representation.
<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.
Map<String,PrologTerm>[]	toTermMapArray(Map<String,T>[] map) Create an equivalent Prolog terms map array using the given native terms map array representation.
<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[][]	toTermMatrix(T[][] terms) Create an equivalent Prolog terms matrix using the given native terms matrix representation.

Method Detail

toTermMapArray

Map<String,PrologTerm>[] toTermMapArray(Map<String,T>[] map)

Create an equivalent Prolog terms map array using the given native terms map array representation. 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.

Parameters:

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

Returns:

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

Since:

1.0

toTermMap

Map<String,PrologTerm> toTermMap(Map<String,T> map)

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

Parameters:

map - native terms map representation to be converted

Returns:

an equivalent Prolog terms map using the given native terms map representation.

Since:

1.0

toTermMatrix

PrologTerm[][] toTermMatrix(T[][] terms)

Create an equivalent Prolog terms matrix using the given native terms matrix representation.

Parameters:

terms - native terms matrix representation to be converted

Returns:

an equivalent Prolog terms matrix using the given native terms matrix representation.

Since:

1.0

toTermArray

PrologTerm[] toTermArray(T[] terms)

Create an equivalent Prolog terms array using the given native terms array representation.

Parameters:

terms - native terms array representation to be converted

Returns:

an equivalent Prolog terms array using the given native terms array representation.

Since:

1.0

toTerm

PrologTerm toTerm(T prologTerm)

Create an equivalent Prolog term using the given native term representation.

Parameters:

prologTerm - native term representation to be converted

Returns:

an equivalent Prolog term using the given native term representation.

Since:

1.0

fromTerm

T fromTerm(PrologTerm term)

Create a native term representation from given Prolog term.

Parameters:

term - Prolog term to be converted to native prolog term

Returns:

native term from given Prolog term.

Since:

1.0

fromTermArray

T[] fromTermArray(PrologTerm[] terms)

Create a native term array representation from given Prolog term array.

Parameters:

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

Returns:

native term array representation from given Prolog term array.

Since:

1.0

fromTerm

T fromTerm(PrologTerm head,
           PrologTerm[] body)

Create a native rule representation term from given head and body.

Parameters:

head - rule head

body - rule body

Returns:

rule representation from given head and body.

Since:

1.0

getGenericClass

Class<T> getGenericClass()

Get the generic class for the current Prolog converter at runtime.

Returns:

the converter generic class

Since:

1.0

createProvider

PrologProvider createProvider()

Create a Prolog provider instance.

Returns:

a Prolog provider instance.

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