AbstractConverter (prolobjectlink-jpi 1.2-SNAPSHOT API)

java.lang.Object
- io.github.prolobjectlink.prolog.AbstractConverter<T>

All Implemented Interfaces:

PrologConverter<T>
```
public abstract class AbstractConverter<T>
extends Object
implements PrologConverter<T>
```
Partial implementation of PrologConverter interface.

Since:

1.0

Author:

Jose Zalacain

Field Summary

Fields
Modifier and Type	Field and Description
`protected PrologProvider`	`provider`
`protected HashMap<String,T>`	`sharedPrologVariables`
`protected HashMap<String,PrologVariable>`	`sharedVariables`
`static String`	`SIMPLE_ATOM_REGEX`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractConverter()

Constructors
Modifier	Constructor and Description
`protected`	`AbstractConverter()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`equals(Object obj)`
`<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.
`Class<T>`	`getGenericClass()` Get the generic class for the current Prolog converter at runtime.
`protected PrologLogger`	`getLogger()`
`int`	`hashCode()`
`String`	`removeQuoted(String functor)`
`<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.
`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[][] 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.
`PrologTerm[][]`	`toTermMatrix(T[][] terms)` Create an equivalent Prolog terms matrix using the given native terms matrix representation.

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

Methods inherited from interface io.github.prolobjectlink.prolog.PrologConverter
createProvider, fromTerm, fromTerm, fromTermArray, toTerm

- Field Detail
  - SIMPLE_ATOM_REGEX
```
public static final String SIMPLE_ATOM_REGEX
```
    See Also:
    
    Constant Field Values
  - sharedVariables
```
protected final HashMap<String,PrologVariable> sharedVariables
```
  - sharedPrologVariables
```
protected final HashMap<String,T> sharedPrologVariables
```
  - provider
```
protected final PrologProvider provider
```
- Constructor Detail
  - AbstractConverter
```
protected AbstractConverter()
```
- Method Detail
  - getLogger
```
protected final PrologLogger getLogger()
```
  - removeQuoted
```
public final String removeQuoted(String functor)
```
  - toTermArray
```
public final PrologTerm[] toTermArray(T[] terms)
```
    Description copied from interface: PrologConverter
    
    Create an equivalent Prolog terms array using the given native terms array representation.
    
    Specified by:
    
    toTermArray in interface PrologConverter<T>
    
    Parameters:
    
    terms - native terms array representation to be converted
    
    Returns:
    
    an equivalent Prolog terms array using the given native terms array representation.
  - toTermMatrix
```
public final PrologTerm[][] toTermMatrix(T[][] terms)
```
    Description copied from interface: PrologConverter
    
    Create an equivalent Prolog terms matrix using the given native terms matrix representation.
    
    Specified by:
    
    toTermMatrix in interface PrologConverter<T>
    
    Parameters:
    
    terms - native terms matrix representation to be converted
    
    Returns:
    
    an equivalent Prolog terms matrix using the given native terms matrix representation.
  - toTermMap
```
public final Map<String,PrologTerm> toTermMap(Map<String,T> map)
```
    Description copied from interface: PrologConverter
    
    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.
    
    Specified by:
    
    toTermMap in interface PrologConverter<T>
    
    Parameters:
    
    map - native terms map representation to be converted
    
    Returns:
    
    an equivalent Prolog terms map using the given native terms map representation.
  - toTermMapArray
```
public final Map<String,PrologTerm>[] toTermMapArray(Map<String,T>[] map)
```
    Description copied from interface: PrologConverter
    
    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.
    
    Specified by:
    
    toTermMapArray in interface PrologConverter<T>
    
    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.
  - 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.
  - 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.
  - getGenericClass
```
public final Class<T> getGenericClass()
```
    Description copied from interface: PrologConverter
    
    Get the generic class for the current Prolog converter at runtime.
    
    Specified by:
    
    getGenericClass in interface PrologConverter<T>
    
    Returns:
    
    the converter generic class
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object

Class AbstractConverter<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

SIMPLE_ATOM_REGEX

sharedVariables

sharedPrologVariables

provider

Constructor Detail

AbstractConverter

Method Detail

getLogger

removeQuoted

toTermArray

toTermMatrix

toTermMap

toTermMapArray

toTerm

toTermArray

toTermMatrix

toTermMap

toTermMapArray

fromTerm

fromTermArray

fromTerm

getGenericClass

hashCode

equals