Package tools.refinery.language.expressions

Class AbstractTermInterpreter

java.lang.Object

tools.refinery.language.expressions.AbstractTermInterpreter

All Implemented Interfaces:

TermInterpreter

Direct Known Subclasses:

BuiltinTermInterpreter

public abstract class AbstractTermInterpreter
extends Object
implements TermInterpreter

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	AbstractTermInterpreter.Cast<R,T>
static interface	AbstractTermInterpreter.Range<T>
static interface	AbstractTermInterpreter.Serializer<A extends AbstractValue<A,C>,C>

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractTermInterpreter()

Method Summary

Modifier and Type	Method	Description
protected void	addAggregator(AggregatorName aggregator, DataExprType type, DataExprType result, AnyPartialAggregator partialAggregator)
protected <R, T1, T2> void	addBinaryOperator(BinaryOp op, DataExprType leftType, DataExprType rightType, DataExprType result, BiFunction<Term<T1>,Term<T2>,Term<R>> termFactory)
protected <R, T> void	addCast(DataExprType fromType, DataExprType toType, AbstractTermInterpreter.Cast<R,T> cast)
protected <A extends AbstractValue<A, C>, C> void	addDomain(DataExprType type, AbstractDomain<A,C> domain, AbstractTermInterpreter.Serializer<A,C> serializer)
protected void	addDomain(DataExprType type, AnyAbstractDomain domain)
protected <R, T> void	addNegation(DataExprType type, DataExprType result, Function<Term<R>,Term<T>> termFactory)
protected void	addOverload(PrimitiveName name, Signature signature, Function<List<AnyTerm>,AnyTerm> termFactory)
protected void	addOverloadInternal(PrimitiveName name, Signature signature, Function<List<AnyTerm>,AnyTerm> termFactory)
protected <R, T> void	addUnaryOperator(UnaryOp op, DataExprType type, DataExprType result, Function<Term<T>,Term<R>> termFactory)
Optional<AnyTerm>	createBinaryOperator(BinaryOp op, DataExprType leftType, DataExprType rightType, AnyTerm left, AnyTerm right)
Optional<AnyTerm>	createCast(DataExprType fromType, DataExprType toType, AnyTerm body)
Optional<Term<TruthValue>>	createComparison(ComparisonOp op, DataExprType type, AnyTerm left, AnyTerm right)
Optional<AnyTerm>	createError(DataExprType type)
Optional<AnyTerm>	createLatticeOperator(LatticeBinaryOp op, DataExprType type, AnyTerm left, AnyTerm right)
<A extends AbstractValue<A, C>, C> AnyTerm	createLatticeOperatorTerm(LatticeBinaryOp op, AbstractDomain<A,C> abstractDomain, AnyTerm left, AnyTerm right)
Optional<AnyTerm>	createNegation(DataExprType type, AnyTerm body)
Optional<AnyTerm>	createNegativeInfinity(DataExprType type)
Optional<AnyTerm>	createOverloadedFunctionCall(PrimitiveName primitive, List<DataExprType> argumentTypes, List<AnyTerm> arguments)
Optional<AnyTerm>	createPositiveInfinity(DataExprType type)
Optional<AnyTerm>	createRange(DataExprType type, AnyTerm left, AnyTerm right)
Optional<AnyTerm>	createUnaryOperator(UnaryOp op, DataExprType type, AnyTerm body)
Optional<AnyTerm>	createUnknown(DataExprType type)
Optional<DataExprType>	getAggregationType(AggregatorName aggregator, DataExprType type)
Optional<AnyPartialAggregator>	getAggregator(AggregatorName aggregator, DataExprType type)
Optional<DataExprType>	getBinaryOperatorType(BinaryOp op, DataExprType leftType, DataExprType rightType)
Optional<AnyAbstractDomain>	getDomain(DataExprType type)
Optional<DataExprType>	getNegationType(DataExprType type)
Optional<Signature>	getOverloadedSignature(PrimitiveName primitive, List<@Nullable DataExprType> argumentTypes)
Optional<DataExprType>	getUnaryOperationType(UnaryOp op, DataExprType type)
boolean	isCastSupported(DataExprType fromType, DataExprType toType)
boolean	isComparable(DataExprType type)
Optional<Expr>	serialize(DataExprType type, Object value)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

AbstractTermInterpreter

protected AbstractTermInterpreter()

Method Details

addDomain

protected void addDomain(DataExprType type,
 AnyAbstractDomain domain)

addDomain

protected <A extends AbstractValue<A,
C>,
C> void addDomain(DataExprType type,
 AbstractDomain<A,C> domain,
 AbstractTermInterpreter.Serializer<A,C> serializer)

addNegation

protected <R,
T> void addNegation(DataExprType type,
 DataExprType result,
 Function<Term<R>,Term<T>> termFactory)

addUnaryOperator

protected <R,
T> void addUnaryOperator(UnaryOp op,
 DataExprType type,
 DataExprType result,
 Function<Term<T>,Term<R>> termFactory)

addBinaryOperator

protected <R,
T1,
T2> void addBinaryOperator(BinaryOp op,
 DataExprType leftType,
 DataExprType rightType,
 DataExprType result,
 BiFunction<Term<T1>,Term<T2>,Term<R>> termFactory)

addCast

protected <R,
T> void addCast(DataExprType fromType,
 DataExprType toType,
 AbstractTermInterpreter.Cast<R,T> cast)

addAggregator

protected void addAggregator(AggregatorName aggregator,
 DataExprType type,
 DataExprType result,
 AnyPartialAggregator partialAggregator)

addOverload

protected void addOverload(PrimitiveName name,
 Signature signature,
 Function<List<AnyTerm>,AnyTerm> termFactory)

addOverloadInternal

protected void addOverloadInternal(PrimitiveName name,
 Signature signature,
 Function<List<AnyTerm>,AnyTerm> termFactory)

getNegationType

public Optional<DataExprType> getNegationType(DataExprType type)

Specified by:

getNegationType in interface TermInterpreter

getDomain

public Optional<AnyAbstractDomain> getDomain(DataExprType type)

Specified by:

getDomain in interface TermInterpreter

createNegation

public Optional<AnyTerm> createNegation(DataExprType type,
 AnyTerm body)

Specified by:

createNegation in interface TermInterpreter

getUnaryOperationType

public Optional<DataExprType> getUnaryOperationType(UnaryOp op,
 DataExprType type)

Specified by:

getUnaryOperationType in interface TermInterpreter

createUnaryOperator

public Optional<AnyTerm> createUnaryOperator(UnaryOp op,
 DataExprType type,
 AnyTerm body)

Specified by:

createUnaryOperator in interface TermInterpreter

isComparable

public boolean isComparable(DataExprType type)

Specified by:

isComparable in interface TermInterpreter

createComparison

public Optional<Term<TruthValue>> createComparison(ComparisonOp op,
 DataExprType type,
 AnyTerm left,
 AnyTerm right)

Specified by:

createComparison in interface TermInterpreter

createLatticeOperator

public Optional<AnyTerm> createLatticeOperator(LatticeBinaryOp op,
 DataExprType type,
 AnyTerm left,
 AnyTerm right)

Specified by:

createLatticeOperator in interface TermInterpreter

createLatticeOperatorTerm

public <A extends AbstractValue<A,
C>,
C> AnyTerm createLatticeOperatorTerm(LatticeBinaryOp op,
 AbstractDomain<A,C> abstractDomain,
 AnyTerm left,
 AnyTerm right)

createBinaryOperator

public Optional<AnyTerm> createBinaryOperator(BinaryOp op,
 DataExprType leftType,
 DataExprType rightType,
 AnyTerm left,
 AnyTerm right)

Specified by:

createBinaryOperator in interface TermInterpreter

createRange

public Optional<AnyTerm> createRange(DataExprType type,
 AnyTerm left,
 AnyTerm right)

Specified by:

createRange in interface TermInterpreter

getBinaryOperatorType

public Optional<DataExprType> getBinaryOperatorType(BinaryOp op,
 DataExprType leftType,
 DataExprType rightType)

Specified by:

getBinaryOperatorType in interface TermInterpreter

getAggregationType

public Optional<DataExprType> getAggregationType(AggregatorName aggregator,
 DataExprType type)

Specified by:

getAggregationType in interface TermInterpreter

getAggregator

public Optional<AnyPartialAggregator> getAggregator(AggregatorName aggregator,
 DataExprType type)

Specified by:

getAggregator in interface TermInterpreter

isCastSupported

public boolean isCastSupported(DataExprType fromType,
 DataExprType toType)

Specified by:

isCastSupported in interface TermInterpreter

createCast

public Optional<AnyTerm> createCast(DataExprType fromType,
 DataExprType toType,
 AnyTerm body)

Specified by:

createCast in interface TermInterpreter

getOverloadedSignature

public Optional<Signature> getOverloadedSignature(PrimitiveName primitive,
 List<@Nullable DataExprType> argumentTypes)

Specified by:

getOverloadedSignature in interface TermInterpreter

createOverloadedFunctionCall

public Optional<AnyTerm> createOverloadedFunctionCall(PrimitiveName primitive,
 List<DataExprType> argumentTypes,
 List<AnyTerm> arguments)

Specified by:

createOverloadedFunctionCall in interface TermInterpreter

createUnknown

public Optional<AnyTerm> createUnknown(DataExprType type)

Specified by:

createUnknown in interface TermInterpreter

createError

public Optional<AnyTerm> createError(DataExprType type)

Specified by:

createError in interface TermInterpreter

createNegativeInfinity

public Optional<AnyTerm> createNegativeInfinity(DataExprType type)

Specified by:

createNegativeInfinity in interface TermInterpreter

createPositiveInfinity

public Optional<AnyTerm> createPositiveInfinity(DataExprType type)

Specified by:

createPositiveInfinity in interface TermInterpreter

serialize

public Optional<Expr> serialize(DataExprType type,
 Object value)

Specified by:

serialize in interface TermInterpreter