final GreaterOrEqualToExpression expression, final StandardExpressionExecutionContext expContext) { Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); result = Boolean.valueOf(leftNumberValue.compareTo(rightNumberValue) != -1); } else { if (leftValue != null && rightValue != null && result = Boolean.valueOf(((Comparable<Object>)leftValue).compareTo(rightValue) >= 0); } else { throw new TemplateProcessingException( "Cannot execute GREATER OR EQUAL TO from Expression \"" + expression.getStringRepresentation() + "\". Left is \"" + new Object[] {TemplateEngine.threadIndex(), expression.getStringRepresentation(), leftValue, rightValue, result});
final Object parameterNameValue = parameterNameExpr.execute(context, expContext); String parameterName = (parameterNameValue == null? null : parameterNameValue.toString()); throw new TemplateProcessingException( "Parameters in link expression \"" + expression.getStringRepresentation() + "\" are " + "incorrect: parameter name expression \"" + parameterNameExpr.getStringRepresentation() + "\" evaluated as null or empty string."); final Object value = parameterValueExpr.execute(context, expContext); if (value == null) {
@Override protected final void doProcess( final ITemplateContext context, final IProcessableElementTag tag, final AttributeName attributeName, final String attributeValue, final IElementTagStructureHandler structureHandler) { if (StringUtils.isEmptyOrWhitespace(attributeValue)) { return; } final ExpressionSequence expressionSequence = ExpressionSequenceUtils.parseExpressionSequence(context, attributeValue); final List<IStandardExpression> expressions = expressionSequence.getExpressions(); for (final IStandardExpression expression : expressions) { final Object expressionResult = expression.execute(context); final boolean expressionBooleanResult = EvaluationUtils.evaluateAsBoolean(expressionResult); if (!expressionBooleanResult) { throw new TemplateAssertionException( expression.getStringRepresentation(), tag.getTemplateName(), tag.getAttribute(attributeName).getLine(), tag.getAttribute(attributeName).getCol()); } } }
final EqualsExpression expression, final StandardExpressionExecutionContext expContext) { Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); result = Boolean.valueOf(leftNumberValue.compareTo(rightNumberValue) == 0); } else { if (leftValue instanceof Character) { new Object[] {TemplateEngine.threadIndex(), expression.getStringRepresentation(), leftValue, rightValue, result});
logger.trace("[THYMELEAF][{}] Evaluating division expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftNumberValue != null && rightNumberValue != null) { try { return leftNumberValue.divide(rightNumberValue); } catch (final ArithmeticException ignored) { return leftNumberValue.divide( rightNumberValue, Math.max(Math.max(leftNumberValue.scale(),rightNumberValue.scale()), 10), RoundingMode.HALF_UP); throw new TemplateProcessingException( "Cannot execute division: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\"");
logger.trace("[THYMELEAF][{}] Evaluating addition expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); StandardExpressions.getVariableExpressionEvaluator(context.getConfiguration()); leftValue = leftExpr.execute(context, expContext); rightValue = rightExpr.execute(context, expContext); if (rightNumberValue != null) { return leftNumberValue.add(rightNumberValue);
static Object executeMultiplication( final IExpressionContext context, final MultiplicationExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating multiplication expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.multiply(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute multiplication: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
static Object executeSubtraction( final IExpressionContext context, final SubtractionExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating subtraction expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.subtract(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute subtraction: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
@Override protected boolean isVisible( final ITemplateContext context, final IProcessableElementTag tag, final AttributeName attributeName, final String attributeValue) { final IStandardExpressionParser expressionParser = StandardExpressions.getExpressionParser(context.getConfiguration()); final IStandardExpression expression = expressionParser.parseExpression(context, attributeValue); final Object value = expression.execute(context); return !EvaluationUtils.evaluateAsBoolean(value); }
static Object executeRemainder( final IExpressionContext context, final RemainderExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating remainder expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.remainder(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute division: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
EscapedAttributeUtils.unescapeAttribute(context.getTemplateMode(), expression); final IStandardExpression expressionObj = expressionParser.parseExpression(context, unescapedExpression); expressionResult = expressionObj.execute(context); } else { expressionResult = null; if (!e.hasTemplateName()) { e.setTemplateName(templateName); if (!e.hasLineAndCol()) { e.setLineAndCol(line, col);
public static Object evaluate(IExpressionContext context, String expressionValue) { final String value = String.valueOf(expressionValue).trim(); final IStandardExpressionParser expressionParser = StandardExpressions .getExpressionParser(context.getConfiguration()); final IStandardExpression expression = expressionParser.parseExpression(context, value); return expression.execute(context); }
@Override protected void doProcess( final ITemplateContext context, final IProcessableElementTag tag, final AttributeName attributeName, final String attributeValue, final IElementTagStructureHandler structureHandler) { final Each each = EachUtils.parseEach(context, attributeValue); final IStandardExpression iterVarExpr = each.getIterVar(); final Object iterVarValue = iterVarExpr.execute(context); final IStandardExpression statusVarExpr = each.getStatusVar(); final Object statusVarValue; if (statusVarExpr != null) { statusVarValue = statusVarExpr.execute(context); } else { statusVarValue = null; // Will provoke the default behaviour: iterVarValue + 'Stat' } final IStandardExpression iterableExpr = each.getIterable(); final Object iteratedValue = iterableExpr.execute(context); final String iterVarName = (iterVarValue == null? null : iterVarValue.toString()); if (StringUtils.isEmptyOrWhitespace(iterVarName)) { throw new TemplateProcessingException( "Iteration variable name expression evaluated as null: \"" + iterVarExpr + "\""); } final String statusVarName = (statusVarValue == null? null : statusVarValue.toString()); if (statusVarExpr != null && StringUtils.isEmptyOrWhitespace(statusVarName)) { throw new TemplateProcessingException( "Status variable name expression evaluated as null or empty: \"" + statusVarExpr + "\""); } structureHandler.iterateElement(iterVarName, statusVarName, iteratedValue); }
final IStandardExpressionParser expressionParser = StandardExpressions.getExpressionParser(configuration); this.logger.trace("[THYMELEAF][{}] Applying javascript variable inline evaluation on \"{}\"", TemplateEngine.threadIndex(), match); expressionParser.parseExpression(configuration, arguments, match); final Object result = expression.execute(configuration, arguments);
/** * helper method to parse a tag value through the IStandardExpressionParser * @param parser standard expression parser * @param context Template context * @param tag tag to be parsed * @param tagName tag attribute name * @return parsed tag value */ <T> T parseTagValue(final IStandardExpressionParser parser, final ITemplateContext context, final IProcessableElementTag tag, final String tagName) { // Parse the attribute value as a Thymeleaf Standard Expression try { return (T) parser.parseExpression(context, tag.getAttributeValue(tagName)).execute(context); } catch (ClassCastException e) { return null; } }
logger.trace("[THYMELEAF][{}] Evaluating message: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); throw new TemplateProcessingException( "Cannot evaluate expression \"" + expression + "\". Message externalization expressions " + "can only be evaluated in a template-processing environment (as a part of an in-template expression) " + Object messageKey = baseExpression.execute(templateContext, expContext); messageKey = LiteralValue.unwrap(messageKey); if (messageKey != null && !(messageKey instanceof String)) { throw new TemplateProcessingException( "Message key for message resolution must be a non-null and non-empty String"); for (int i = 0; i < parameterExpressionValuesLen; i++) { final IStandardExpression parameterExpression = parameterExpressionValues.get(i); final Object result = parameterExpression.execute(templateContext, expContext); messageParameters[i] = LiteralValue.unwrap(result); return templateContext.getMessage(null, (String)messageKey, messageParameters, true);
logger.trace("[THYMELEAF][{}] Evaluating link: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); throw new TemplateProcessingException( "Cannot evaluate expression \"" + expression + "\". Link expressions " + "can only be evaluated in a template-processing environment (as a part of an in-template expression) " + Object base = baseExpression.execute(templateContext, StandardExpressionExecutionContext.RESTRICTED); return templateContext.buildLink((String)base, parameters);
logger.trace("[THYMELEAF][{}] Evaluating message: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); throw new TemplateProcessingException( "Cannot evaluate expression \"" + expression + "\". Message externalization expressions " + "can only be evaluated in a template-processing environment (as a part of an in-template expression) " + Object messageKey = baseExpression.execute(configuration, arguments, expContext); messageKey = LiteralValue.unwrap(messageKey); if (messageKey != null && !(messageKey instanceof String)) { throw new TemplateProcessingException( "Message key for message resolution must be a non-null and non-empty String"); int parIndex = 0; for (final IStandardExpression parameter : expression.getParameters()) { final Object result = parameter.execute(configuration, arguments, expContext); messageParameters[parIndex++] = LiteralValue.unwrap(result);
static Object executeAnd( final IExpressionContext context, final AndExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating AND expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } final Object leftValue = expression.getLeft().execute(context, expContext); // Short circuit final boolean leftBooleanValue = EvaluationUtils.evaluateAsBoolean(leftValue); if (!leftBooleanValue) { return Boolean.FALSE; } final Object rightValue = expression.getRight().execute(context, expContext); final boolean rightBooleanValue = EvaluationUtils.evaluateAsBoolean(rightValue); return Boolean.valueOf(rightBooleanValue); }
final IStandardExpressionParser expressionParser = StandardExpressions.getExpressionParser(context.getConfiguration()); if (!(expressionParser instanceof StandardExpressionParser)) { final Object result = expression.execute(context, StandardExpressionExecutionContext.RESTRICTED);