public Expression createLogicalComplementExpression(
final String name, final Expression expression) throws InvalidExpressionException {
createNewInstance(name)
.setExpressionType(ExpressionType.TYPE_CONDITION)
.setReturnType(Boolean.class.getName())
.setContent(NOT_COMPARATOR);
setDependencies(Collections.singletonList(expression));
return done();
}
public Expression createExpression(
final String name,
final String content,
final ExpressionType type,
final String returnType,
final String interpreter,
final List<Expression> dependencies)
throws InvalidExpressionException {
createNewInstance(name).setContent(content).setExpressionType(type).setReturnType(returnType);
if (interpreter == null) {
setInterpreter("NONE"); // interpreter,ExpressionInterpreter.GROOVY.toString()
} else {
setInterpreter(interpreter);
}
if (dependencies == null) {
setDependencies(new ArrayList<Expression>());
} else {
setDependencies(dependencies);
}
return done();
}
/**
* Create an expression to call a simple Java method (without parameters)
*
* @param name the expression name
* @param methodName the name of method to call
* @param returnType the method return type
* @param entityExpression the expression representing the entity (Java Object) where the method
* will be called
* @return the created expression
* @throws InvalidExpressionException if the created expression is invalid
* @since 6.0
*/
public Expression createJavaMethodCallExpression(
final String name,
final String methodName,
final String returnType,
final Expression entityExpression)
throws InvalidExpressionException {
createNewInstance(name)
.setExpressionType(ExpressionType.TYPE_JAVA_METHOD_CALL)
.setReturnType(returnType)
.setContent(methodName);
setDependencies(Collections.singletonList(entityExpression));
return done();
}
public Expression createComparisonExpression(
final String name,
final Expression leftOperand,
final String operator,
final Expression rightOperand)
throws InvalidExpressionException {
createNewInstance(name)
.setExpressionType(ExpressionType.TYPE_CONDITION)
.setReturnType(Boolean.class.getName())
.setContent(operator);
final List<Expression> dependencies = new ArrayList<Expression>(2);
dependencies.add(leftOperand);
dependencies.add(rightOperand);
setDependencies(dependencies);
return done();
}
public Expression createXPathExpression(
final String name,
final String xPathExpression,
final XPathReturnType returnType,
final String xmlContent)
throws InvalidExpressionException {
final ExpressionBuilder expBuilder =
createNewInstance(name)
.setExpressionType(ExpressionType.TYPE_XPATH_READ)
.setContent(xPathExpression);
getXPathReturnType(returnType, expBuilder);
final Expression dep =
new ExpressionBuilder()
.createNewInstance("xmlContent")
.setContent(xmlContent)
.setExpressionType(ExpressionType.TYPE_CONSTANT)
.setReturnType(String.class.getName())
.done();
expBuilder.setDependencies(Arrays.asList(dep));
return expBuilder.done();
}
