public interface StateResolver {

    int resolve(String stringState);

}

    @Override
    public Predicate<T> convert(List<Criterion> criteria) {
        return criteria.stream()
                .map(criterionOperatorRegistry::<T>toPredicate)
                .reduce(x -> true, Predicate::and);
    }

    @Override
    public Predicate<E> convert(List<Criterion> criteria) {
        return criteria.stream()
                .map(criterion -> {
                    if (criterion.getOperandLeft().equals("state") && criterion.getOperandRight() instanceof String stateString) {
                        return criterion(criterion.getOperandLeft(), criterion.getOperator(), stateResolver.resolve(stateString));
                    }
                    return criterion;
                })
                .map(criterionOperatorRegistry::<E>toPredicate)
                .reduce(x -> true, Predicate::and);
    }

public class EntityStateFieldTranslator extends PlainColumnFieldTranslator {

    private final StateResolver stateResolver;

    public EntityStateFieldTranslator(String columnName, StateResolver stateResolver) {
        super(columnName);
        this.stateResolver = stateResolver;
    }

    @Override
    public Collection<Object> toParameters(Criterion criterion) {
        return super.toParameters(criterion)
                .stream()
                .map(it -> it instanceof String stringState ? stateResolver.resolve(stringState) : it)
                .collect(toList());
    }
}