public Object execute( final IExpressionContext context) { return execute(context, StandardExpressionExecutionContext.NORMAL); }
@Override public String toString() { return getStringRepresentation(); }
static Object executeDefault( final IExpressionContext context, final DefaultExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating default expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } final Object queriedValue = expression.getQueriedExpression().execute(context, expContext); if (queriedValue == null) { return expression.getDefaultExpression().execute(context, expContext); } return queriedValue; }
@Override public String toString() { return (isExpression()? "[" + this.expression.getStringRepresentation() + "]" : this.input); }
static Object executeConditional( final IExpressionContext context, final ConditionalExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating conditional expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } final Object condObj = expression.getConditionExpression().execute(context, expContext); final boolean cond = EvaluationUtils.evaluateAsBoolean(condObj); if (cond) { return expression.getThenExpression().execute(context, expContext); } return expression.getElseExpression().execute(context, expContext); }
@Override public String toString() { return getStringRepresentation(); }
static Object executeNegation( final IExpressionContext context, final NegationExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating negation expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } final Object operandValue = expression.getOperand().execute(context, expContext); final boolean operandBooleanValue = EvaluationUtils.evaluateAsBoolean(operandValue); return Boolean.valueOf(!operandBooleanValue); }
private static AssignationSequence createSyntheticallyNamedParameterSequence(final ExpressionSequence expSeq) { final List<Assignation> assignations = new ArrayList<Assignation>(expSeq.size() + 2); int argIndex = 0; for (final IStandardExpression expression : expSeq.getExpressions()) { final IStandardExpression parameterName = Expression.parse(TextLiteralExpression.wrapStringIntoLiteral(UNNAMED_PARAMETERS_PREFIX + argIndex++)); assignations.add(new Assignation(parameterName, expression)); } return new AssignationSequence(assignations); }
@Override public String toString() { return (isExpression()? "[" + this.expression.getStringRepresentation() + "]" : this.input); }
static Object executeMinus( final IExpressionContext context, final MinusExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating minus expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object operandValue = expression.getOperand().execute(context, expContext); if (operandValue == null) { operandValue = "null"; } final BigDecimal operandNumberValue = EvaluationUtils.evaluateAsNumber(operandValue); if (operandNumberValue != null) { // Addition will act as a mathematical 'plus' return operandNumberValue.multiply(BigDecimal.valueOf(-1)); } throw new TemplateProcessingException( "Cannot execute minus: operand is \"" + LiteralValue.unwrap(operandValue) + "\""); }
static IStandardExpression parseExpression( final IExpressionContext context, final String input, final boolean preprocess) { final IEngineConfiguration configuration = context.getConfiguration(); final String preprocessedInput = (preprocess? StandardExpressionPreprocessor.preprocess(context, input) : input); final IStandardExpression cachedExpression = ExpressionCache.getExpressionFromCache(configuration, preprocessedInput); if (cachedExpression != null) { return cachedExpression; } final Expression expression = Expression.parse(preprocessedInput.trim()); if (expression == null) { throw new TemplateProcessingException("Could not parse as expression: \"" + input + "\""); } ExpressionCache.putExpressionIntoCache(configuration, preprocessedInput, expression); return expression; }
public Object execute( final IExpressionContext context, final StandardExpressionExecutionContext expContext) { Validate.notNull(context, "Context cannot be null"); final IStandardVariableExpressionEvaluator variableExpressionEvaluator = StandardExpressions.getVariableExpressionEvaluator(context.getConfiguration()); final Object result = execute(context, this, variableExpressionEvaluator, expContext); return LiteralValue.unwrap(result); }
if (leftExpr instanceof Expression) { leftValue = Expression.execute(context, (Expression)leftExpr, expressionEvaluator, expContext); } else{ leftValue = leftExpr.execute(context, expContext); if (rightExpr instanceof Expression) { rightValue = Expression.execute(context, (Expression)rightExpr, expressionEvaluator, expContext); } else{ rightValue = rightExpr.execute(context, expContext);
public Object execute(final Configuration configuration, final IProcessingContext processingContext) { return execute(configuration, processingContext, StandardExpressionExecutionContext.NORMAL); }