public Expression parseExpression(String expression, Class expectedType, FunctionMapper fMapper ) throws ELException { ExpressionFactory fac = ExpressionFactory.newInstance(); javax.el.ValueExpression expr; ELContextImpl elContext = new ELContextImpl(null); javax.el.FunctionMapper fm = new FunctionMapperWrapper(fMapper); elContext.setFunctionMapper(fm); try { expr = fac.createValueExpression( elContext, expression, expectedType); } catch (javax.el.ELException ex) { throw new ELException(ex); } return new ExpressionImpl(expr, pageContext); }
@Override public Expression parseExpression(String expression, @SuppressWarnings("rawtypes") // API does not use generics Class expectedType, FunctionMapper fMapper) throws ELException { try { ELContextImpl ctx = new ELContextImpl(ELContextImpl.getDefaultResolver()); if (fMapper != null) { ctx.setFunctionMapper(new FunctionMapperImpl(fMapper)); } ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType); return new ExpressionImpl(ve); } catch (javax.el.ELException e) { throw new ELParseException(e.getMessage()); } }
@Override public Expression parseExpression(String expression, @SuppressWarnings("rawtypes") // API // does // not // use // generics Class expectedType, FunctionMapper fMapper) throws ELException { try { ELContextImpl ctx = new ELContextImpl(ELContextImpl.getDefaultResolver()); if (fMapper != null) { ctx.setFunctionMapper(new FunctionMapperImpl(fMapper)); } ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType); return new ExpressionImpl(ve); } catch (javax.el.ELException e) { throw new ELParseException(e.getMessage()); } }
public Object evaluate(VariableResolver vResolver) throws ELException { ELContext elContext; if (vResolver instanceof VariableResolverImpl) { elContext = pageContext.getELContext(); } else { // The provided variable Resolver is a custom resolver, // wrap it with a ELResolver elContext = new ELContextImpl(new ELResolverWrapper(vResolver)); } try { return valueExpr.getValue(elContext); } catch (javax.el.ELException ex) { throw new ELException(ex); } }
@Override public Expression parseExpression(String expression, @SuppressWarnings("rawtypes") // API does not use generics Class expectedType, FunctionMapper fMapper) throws ELException { try { ELContextImpl ctx = new ELContextImpl(ELResolverImpl.getDefaultResolver()); if (fMapper != null) { ctx.setFunctionMapper(new FunctionMapperImpl(fMapper)); } ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType); return new ExpressionImpl(ve); } catch (javax.el.ELException e) { throw new ELParseException(e.getMessage()); } }
/** * VariableResolver interface */ @Override @Deprecated public Object resolveVariable(String pName) throws ELException { ELContext ctx = this.getELContext(); return ctx.getELResolver().getValue(ctx, null, pName); }
@Override public Object evaluate(String expression, @SuppressWarnings("rawtypes") // API does not use generics Class expectedType, VariableResolver vResolver, FunctionMapper fMapper) throws ELException { return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver); }
public Expression parseExpression(String expression, Class expectedType, FunctionMapper fMapper) throws ELException { try { ELContextImpl ctx = new ELContextImpl(ELResolverImpl.getDefaultResolver()); if (fMapper != null) { ctx.setFunctionMapper(new FunctionMapperImpl(fMapper)); } ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType); return new ExpressionImpl(ve); } catch (javax.el.ELException e) { throw new ELParseException(e.getMessage()); } }
@Override public Object evaluate(String expression, @SuppressWarnings("rawtypes") // API // does // not // use // generics Class expectedType, VariableResolver vResolver, FunctionMapper fMapper) throws ELException { return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver); }
/** * Recognizes a couple of special variables, and if the property requested * isn't one of them, just looks up a property on the action bean. * * @param property the name of the variable/property being looked for * @return the property value or null * @throws javax.servlet.jsp.el.ELException */ public Object resolveVariable(String property) throws ELException { if (isSelfKeyword(bean, property)) { return this.currentValue; } else if (StripesConstants.REQ_ATTR_ACTION_BEAN.equals(property)) { return this.bean; } else { try { return BeanUtil.getPropertyValue(property, bean); } catch (Exception e) { return null; } } }
public Object evaluate(String expression, Class expectedType, VariableResolver vResolver, FunctionMapper fMapper ) throws ELException { ELContextImpl elContext; if (vResolver instanceof VariableResolverImpl) { elContext = (ELContextImpl) pageContext.getELContext(); } else { // The provided variable Resolver is a custom resolver, // wrap it with a ELResolver elContext = new ELContextImpl(new ELResolverWrapper(vResolver)); } javax.el.FunctionMapper fm = new FunctionMapperWrapper(fMapper); elContext.setFunctionMapper(fm); ExpressionFactory fac = ExpressionFactory.newInstance(); Object value; try { ValueExpression expr = fac.createValueExpression( elContext, expression, expectedType); value = expr.getValue(elContext); } catch (javax.el.ELException ex) { throw new ELException(ex); } return value; }
public Object getValue(ELContext context, Object base, Object property) throws javax.el.ELException { if (base == null) { context.setPropertyResolved(true); try { return vResolver.resolveVariable(property.toString()); } catch (ELException ex) { throw new javax.el.ELException(ex); } } return null; }
private Throwable getRootCause(Throwable ex) { final Throwable rx; if (ex instanceof ServletException) { rx = ((ServletException) ex).getRootCause(); } else if (ex instanceof ELException) { rx = ((ELException) ex).getRootCause(); } else if (ex != null) { rx = ex.getCause(); } else { rx = null; } return rx == null ? ex : getRootCause(rx); }
public static void parseEL(String el) throws ELEvalException { try { EVALUATOR.parseExpressionString(el); } catch (ELException e) { LOG.debug("Error parsering EL '{}': {}", el, e.toString(), e); throw new ELEvalException(CommonError.CMN_0105, el, e.toString(), e); } }
@Override @SuppressWarnings("unchecked") public <T> T evaluate (final ELVars vars, String expression, Class<T> returnType) throws ELEvalException { VariableResolver variableResolver = new VariableResolver() { @Override public Object resolveVariable(String name) throws ELException { Object value = constants.get(name); if (!vars.hasVariable(name)) { if (value == null && !constants.containsKey(name)) { throw new ELException(Utils.format("Constants/Variable '{}' cannot be resolved", name)); } } else { value = vars.getVariable(name); } return value; } }; try { return (T) EVALUATOR.evaluate(expression, returnType, variableResolver, functionMapper); } catch (ELException e) { // Apache evaluator is not using the getCause exception chaining that is available in Java but rather a custom // chaining mechanism. This doesn't work well for us as we're effectively swallowing the cause that is not // available in log, ... Throwable t = e; if(e.getRootCause() != null) { t = e.getRootCause(); if(e.getCause() == null) { e.initCause(t); } } LOG.debug("Error valuating EL '{}': {}", expression, e.toString(), e); throw new ELEvalException(CommonError.CMN_0104, expression, t.toString(), e); } }
@Override public Expression parseExpression( final String expression, final Class expectedType, final FunctionMapper functionMapper) throws ELException { return new Expression() { @Override public Object evaluate(VariableResolver variableResolver) throws ELException { return doEvaluate(expression, expectedType, functionMapper); } }; }
@Override public Object evaluate( String expression, Class expectedType, VariableResolver variableResolver, FunctionMapper functionMapper) throws ELException { if (variableResolver != null) { throw new IllegalArgumentException("Custom VariableResolver not supported"); } return doEvaluate(expression, expectedType, functionMapper); }
protected Object doEvaluate( String expression, Class expectedType, FunctionMapper functionMapper) throws ELException { if (functionMapper != null) { throw new IllegalArgumentException("Custom FunctionMapper not supported"); } try { return ExpressionEvaluatorManager.evaluate("JSP EL expression", expression, expectedType, this.pageContext); } catch (JspException ex) { throw new ELException("Parsing of JSP EL expression \"" + expression + "\" failed", ex); } }
@SuppressWarnings("rawtypes") public Expression parseExpression(final String expression, final Class expectedType, final FunctionMapper functionMapper) throws ELException { return new Expression() { public Object evaluate(VariableResolver variableResolver) throws ELException { return doEvaluate(expression, expectedType, functionMapper); } }; }
@SuppressWarnings("rawtypes") public Object evaluate(String expression, Class expectedType, VariableResolver variableResolver, FunctionMapper functionMapper) throws ELException { if (variableResolver != null) { throw new IllegalArgumentException("Custom VariableResolver not supported"); } return doEvaluate(expression, expectedType, functionMapper); }
@SuppressWarnings("rawtypes") protected Object doEvaluate(String expression, Class expectedType, FunctionMapper functionMapper) throws ELException { if (functionMapper != null) { throw new IllegalArgumentException("Custom FunctionMapper not supported"); } try { return ExpressionEvaluatorManager.evaluate("JSP EL expression", expression, expectedType, this.pageContext); } catch (JspException ex) { throw new ELException("Parsing of JSP EL expression \"" + expression + "\" failed", ex); } }
