javax.servlet.jsp.el.VariableResolver Java Examples

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 Object evaluate(String expression,
        @SuppressWarnings("rawtypes") Class expectedType,
        VariableResolver vResolver, FunctionMapper fMapper)
        throws ELException {
    return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver);
}
 

@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);
}
 

@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(ContainerCommonError.CTRCMN_0100, expression, t.toString(), e);
  }
}
 

@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 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;
}
 

@Override
public VariableResolver getVariableResolver()
{
  throw new UnsupportedOperationException();
}
 

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}
 

@Override
public VariableResolver getVariableResolver() {

    return null;
}
 

@Override
public VariableResolver getVariableResolver() {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public VariableResolver getVariableResolver() {
  throw new UnsupportedOperationException();
}
 

@Override
public Object evaluate(String arg0, Class arg1, VariableResolver arg2, FunctionMapper arg3) throws ELException {
	return null;
}
 

public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this);
}
 

public VariableResolver getVariableResolver() {
return null;
   }
 

ELResolverWrapper(VariableResolver vResolver) {
    this.vResolver = vResolver;
}
 

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver();
}
 

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}
 

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}
 

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}
 

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver();
}
 

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}
 

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}
 

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}
 

public ELResolverImpl(VariableResolver variableResolver,
        ExpressionFactory factory) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver(factory);
}
 

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx =
            new ELContextImpl(new ELResolverImpl(vResolver, factory));
    return ve.getValue(ctx);
}
 

/**
 * Returns an instance of a VariableResolver that provides access to the
 * implicit objects specified in the JSP specification using this JspContext
 * as the context object.
 *
 * @deprecated As of JSP 2.1, replaced by {@link ELContext#getELResolver},
 *     which can be obtained by 
 *     <code>jspContext.getELContext().getELResolver()</code>.
 * @return A valid instance of a VariableResolver.
 * @since JSP 2.0
 */
public abstract VariableResolver getVariableResolver();