95 lines
2.5 KiB
Java
95 lines
2.5 KiB
Java
package expression.common;
|
|
|
|
import base.ExtendedRandom;
|
|
import base.Functional;
|
|
import base.Pair;
|
|
import expression.ToMiniString;
|
|
|
|
import java.util.List;
|
|
|
|
/**
|
|
* @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
|
|
*/
|
|
public class ExpressionKind<E extends ToMiniString, C> {
|
|
private final Type<C> type;
|
|
private final Class<E> kind;
|
|
private final Variables<E> variables;
|
|
private final Evaluator<E, C> evaluator;
|
|
|
|
public ExpressionKind(
|
|
final Type<C> type,
|
|
final Class<E> kind,
|
|
final Variables<E> variables,
|
|
final Evaluator<E, C> evaluator
|
|
) {
|
|
this.type = type;
|
|
this.kind = kind;
|
|
this.variables = variables;
|
|
this.evaluator = evaluator;
|
|
}
|
|
|
|
public ExpressionKind(
|
|
final Type<C> type,
|
|
final Class<E> kind,
|
|
final List<Pair<String, E>> variables,
|
|
final Evaluator<E, C> evaluator
|
|
) {
|
|
this(type, kind, (r, c) -> variables, evaluator);
|
|
}
|
|
|
|
public C evaluate(final E expression, final List<String> variables, final List<C> values) throws Exception {
|
|
return evaluator.evaluate(expression, variables, values);
|
|
}
|
|
|
|
public E cast(final Object expression) {
|
|
return kind.cast(expression);
|
|
}
|
|
|
|
public String getName() {
|
|
return kind.getSimpleName();
|
|
}
|
|
|
|
public E constant(final C value) {
|
|
return cast(type.constant(value));
|
|
}
|
|
|
|
public C randomValue(final ExtendedRandom random) {
|
|
return type.randomValue(random);
|
|
}
|
|
|
|
public List<List<C>> allValues(final int length, final List<Integer> values) {
|
|
return Functional.allValues(fromInts(values), length);
|
|
}
|
|
|
|
public List<C> fromInts(final List<Integer> values) {
|
|
return Functional.map(values, this::fromInt);
|
|
}
|
|
|
|
public C fromInt(final int value) {
|
|
return type.fromInt(value);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return kind.getName();
|
|
}
|
|
|
|
public ExpressionKind<E, C> withVariables(final Variables<E> variables) {
|
|
return new ExpressionKind<>(type, kind, variables, evaluator);
|
|
}
|
|
|
|
public Variables<E> variables() {
|
|
return variables;
|
|
}
|
|
|
|
@FunctionalInterface
|
|
public interface Variables<E> {
|
|
List<Pair<String, E>> generate(final ExtendedRandom random, final int count);
|
|
}
|
|
|
|
@FunctionalInterface
|
|
public interface Evaluator<E, R> {
|
|
R evaluate(final E expression, final List<String> vars, final List<R> values) throws Exception;
|
|
}
|
|
}
|