AbstractProvider (prolobjectlink-jpi 1.2-SNAPSHOT API)

java.lang.Object
- io.github.prolobjectlink.prolog.AbstractProvider

All Implemented Interfaces:

PrologProvider
```
public abstract class AbstractProvider
extends Object
implements PrologProvider
```
Partial implementation of PrologProvider

Since:

1.0

Author:

Jose Zalacain

Field Summary

Fields
Modifier and Type Field and Description

protected PrologConverter<?> converter

Fields
Modifier and Type	Field and Description
`protected PrologConverter<?>`	`converter`

Constructor Summary

Constructors
Constructor and Description

AbstractProvider(PrologConverter<?> converter)

Constructors
Constructor and Description
`AbstractProvider(PrologConverter<?> converter)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
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.
`protected <T extends PrologTerm> T`	`cast(PrologTerm term, Class<T> type)` Casts a PrologTerm to the class or interface represented by this `Class` object.
`boolean`	`equals(Object object)`
`<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.
`PrologConverter<?>`	`getConverter()` Get a prolog converter instance to map the abstract prolog data types to under-laying prolog implementations data types.
`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.
`int`	`hashCode()`
`boolean`	`isCompliant()` True if wrapped engine implement ISO Prolog and false in other case
`PrologDouble`	`newDouble()` Create a prolog double number instance with 0.0 value.
`PrologFloat`	`newFloat()` Create a prolog float number instance with 0.0 value.
`PrologInteger`	`newInteger()` Create a prolog integer number instance with 0 value.
`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.
`PrologLong`	`newLong()` Create a prolog long number instance with 0 value.
`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(String functor, Object... arguments)` Create a prolog structure with the functor (structure name) and java objects arguments array.
`PrologClause`	`parseClause(String stringClause)` 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.
`protected String`	`removeQuoted(String functor)`
`abstract String`	`toString()`
`<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[] os, 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[][] oss, 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.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.github.prolobjectlink.prolog.PrologProvider
falseReference, getJavaConverter, getLogger, newAtom, newDouble, newEngine, newEngine, newEntry, newEntry, newFloat, newInteger, newList, newList, newList, newList, newLong, newMap, newMap, newMap, newReference, newStructure, newStructure, newVariable, newVariable, nullReference, prologCut, prologEmpty, prologFail, prologFalse, prologInclude, prologNil, prologTrue, trueReference, voidReference

- Field Detail
  - converter
```
protected final PrologConverter<?> converter
```
- Constructor Detail
  - AbstractProvider
```
public AbstractProvider(PrologConverter<?> converter)
```
- Method Detail
  - removeQuoted
```
protected final String removeQuoted(String functor)
```
  - isCompliant
```
public final boolean isCompliant()
```
    Description copied from interface: PrologProvider
    
    True if wrapped engine implement ISO Prolog and false in other case
    
    Specified by:
    
    isCompliant in interface PrologProvider
    
    Returns:
    
    true if wrapped engine implement ISO Prolog and false in other case
  - parseList
```
public final 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.
  - parseClause
```
public final PrologClause parseClause(String stringClause)
```
    Parse the string with Prolog syntax and create an equivalent Prolog clause instance.
    
    Parameters:
    
    stringClause - prolog clause in string format.
    
    Returns:
    
    a Prolog clause from prolog text.
  - parseStructure
```
public final 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.
  - parseProgram
```
public final 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.
  - parseProgram
```
public final 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.
  - newFloat
```
public final PrologFloat newFloat()
```
    Description copied from interface: PrologProvider
    
    Create a prolog float number instance with 0.0 value.
    
    Specified by:
    
    newFloat in interface PrologProvider
    
    Returns:
    
    prolog float number with 0.0 value.
  - newDouble
```
public final PrologDouble newDouble()
```
    Description copied from interface: PrologProvider
    
    Create a prolog double number instance with 0.0 value.
    
    Specified by:
    
    newDouble in interface PrologProvider
    
    Returns:
    
    prolog double number with 0.0 value.
  - newInteger
```
public final PrologInteger newInteger()
```
    Description copied from interface: PrologProvider
    
    Create a prolog integer number instance with 0 value.
    
    Specified by:
    
    newInteger in interface PrologProvider
    
    Returns:
    
    prolog integer number with 0 value.
  - newLong
```
public final PrologLong newLong()
```
    Description copied from interface: PrologProvider
    
    Create a prolog long number instance with 0 value.
    
    Specified by:
    
    newLong in interface PrologProvider
    
    Returns:
    
    prolog long number with 0 value.
  - newList
```
public final PrologList newList(PrologTerm head)
```
    Description copied from interface: PrologProvider
    
    Create a prolog list with one term item.
    
    Specified by:
    
    newList in interface PrologProvider
    
    Parameters:
    
    head - term item to be include in the prolog list
    
    Returns:
    
    prolog list with one term item.
  - newList
```
public final PrologList newList(Object head)
```
    Description copied from interface: PrologProvider
    
    Create a prolog list with one object item.
    
    Specified by:
    
    newList in interface PrologProvider
    
    Parameters:
    
    head - object item to be include in the prolog list
    
    Returns:
    
    prolog list with one term item.
  - newList
```
public final PrologList newList(Object[] arguments)
```
    Description copied from interface: PrologProvider
    
    Create a prolog list from java objects arguments array and the tail item is an empty list.
    
    Specified by:
    
    newList in interface PrologProvider
    
    Parameters:
    
    arguments - java objects arguments array.
    
    Returns:
    
    a prolog list contained all terms in the prolog term array.
  - newList
```
public final PrologList newList(Object head,
                                Object tail)
```
    Description copied from interface: PrologProvider
    
    Create a prolog list with two java objects items [head | tail].
    
    Specified by:
    
    newList in interface PrologProvider
    
    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].
  - newList
```
public final PrologList newList(Object[] arguments,
                                Object tail)
```
    Description copied from interface: PrologProvider
    
    Create a prolog list from java objects arguments array and the tail item is the given java object.
    
    Specified by:
    
    newList in interface PrologProvider
    
    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.
  - newStructure
```
public final PrologTerm newStructure(String functor,
                                     Object... arguments)
```
    Description copied from interface: PrologProvider
    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);
 
```
    Specified by:
    
    newStructure in interface PrologProvider
    
    Parameters:
    
    functor - structure name.
    
    arguments - java objects arguments array.
    
    Returns:
    
    prolog structure instance with the given functor and arguments.
  - newStructure
```
public final PrologTerm newStructure(Object left,
                                     String operator,
                                     Object right)
```
    Description copied from interface: PrologProvider
    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);
 
```
    Specified by:
    
    newStructure in interface PrologProvider
    
    Parameters:
    
    left - left hand operand
    
    operator - infix operand
    
    right - right hand operand
    
    Returns:
    
    a prolog structure that represent an expression
  - cast
```
protected final <T extends PrologTerm> T cast(PrologTerm term,
                                              Class<T> type)
```
    Casts a PrologTerm to the class or interface represented by this Class object.
    
    Parameters:
    
    term - the object to be cast
    
    type - the class or interface to be casted
    
    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
  - cast
```
public final <T extends PrologTerm> T cast(PrologTerm term)
```
    Description copied from interface: PrologProvider
    
    Casts a PrologTerm to the class or interface represented by this Class object.
    
    Specified by:
    
    cast in interface PrologProvider
    
    Parameters:
    
    term - the object to be cast
    
    Returns:
    
    the PrologTerm after casting, or null if term is null
  - toTerm
```
public final <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.
  - toTermArray
```
public final <K extends PrologTerm> K[] toTermArray(Object[] os,
                                                    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:
    
    os - 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.
  - toTermMatrix
```
public final <K extends PrologTerm> K[][] toTermMatrix(Object[][] oss,
                                                       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:
    
    oss - 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.
  - toTermMap
```
public final <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.
  - toTermMapArray
```
public final <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.
  - getConverter
```
public final PrologConverter<?> getConverter()
```
    Description copied from interface: PrologProvider
    
    Get a prolog converter instance to map the abstract prolog data types to under-laying prolog implementations data types.
    
    Specified by:
    
    getConverter in interface PrologProvider
    
    Returns:
    
    prolog converter instance
  - fromTerm
```
public final <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.
  - fromTermArray
```
public final <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.
  - fromTerm
```
public final <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.
  - getParser
```
public final io.github.prolobjectlink.prolog.PrologParser getParser()
```
    Description copied from interface: PrologProvider
    
    Get a prolog parser instance to parser the strings with prolog syntax.
    
    Specified by:
    
    getParser in interface PrologProvider
    
    Returns:
    
    prolog parser instance
  - getVersion
```
public final String getVersion()
```
    Description copied from interface: PrologProvider
    
    Version of the wrapped engine.
    
    Specified by:
    
    getVersion in interface PrologProvider
    
    Returns:
    
    String version of the wrapped engine.
  - getName
```
public final String getName()
```
    Description copied from interface: PrologProvider
    
    Name of the wrapped engine.
    
    Specified by:
    
    getName in interface PrologProvider
    
    Returns:
    
    String name of the wrapped engine.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object object)
```
    Overrides:
    
    equals in class Object
  - toString
```
public abstract String toString()
```
    Overrides:
    
    toString in class Object
  - parseTerm
```
public 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
```
public 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

Class AbstractProvider

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.github.prolobjectlink.prolog.PrologProvider

Field Detail

converter

Constructor Detail

AbstractProvider

Method Detail

removeQuoted

isCompliant

parseList

parseClause

parseStructure

parseProgram

parseProgram

newFloat

newDouble

newInteger

newLong

newList

newList

newList

newList

newList

newStructure

newStructure

cast

cast

toTerm

toTermArray

toTermMatrix

toTermMap

toTermMapArray

getConverter

fromTerm

fromTermArray

fromTerm

getParser

getVersion

getName

hashCode

equals

toString

parseTerm

parseTerms