/** * * Gets the value of the index **/ Object evaluateIndex (VariableResolver pResolver, FunctionMapper functions, Logger pLogger) throws ELException { return mIndex.evaluate (pResolver, functions, pLogger); }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { return "[" + mIndex.getExpressionString () + "]"; }
/** * * Evaluates the conditional expression and returns the literal result **/ public Object evaluate (VariableResolver vr, FunctionMapper f, Logger l) throws ELException { // first, evaluate the condition (and coerce the result to a boolean value) boolean condition = Coercions.coerceToBoolean( mCondition.evaluate(vr, f, l), l).booleanValue(); // then, use this boolean to branch appropriately if (condition) return mTrueBranch.evaluate(vr, f, l); else return mFalseBranch.evaluate(vr, f, l); }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { return "( " + mCondition.getExpressionString() + " ? " + mTrueBranch.getExpressionString() + " : " + mFalseBranch.getExpressionString() + " )"; }
/** * * Evaluates by evaluating the prefix, then applying the suffixes **/ public Object evaluate (VariableResolver pResolver, FunctionMapper functions, Logger pLogger) throws ELException { Object ret = mPrefix.evaluate (pResolver, functions, pLogger); // Apply the suffixes for (int i = 0; mSuffixes != null && i < mSuffixes.size (); i++) { ValueSuffix suffix = (ValueSuffix) mSuffixes.get (i); ret = suffix.evaluate (ret, pResolver, functions, pLogger); } return ret; }
/** * Returns the expression in the expression language syntax **/ public String getExpressionString () { StringBuffer b = new StringBuffer(); b.append(functionName); b.append("("); Iterator i = argumentList.iterator(); while (i.hasNext()) { b.append(((Expression) i.next()).getExpressionString()); if (i.hasNext()) b.append(", "); } b.append(")"); return b.toString(); }
/** * * Evaluates the expression string by evaluating each element, * converting it to a String (using toString, or "" for null values) * and concatenating the results into a single String. **/ public String evaluate (VariableResolver pResolver, FunctionMapper functions, Logger pLogger) throws ELException { StringBuffer buf = new StringBuffer (); for (int i = 0; i < mElements.length; i++) { Object elem = mElements [i]; if (elem instanceof String) { buf.append ((String) elem); } else if (elem instanceof Expression) { Object val = ((Expression) elem).evaluate (pResolver, functions, pLogger); if (val != null) { buf.append (val.toString ()); } } } return buf.toString (); }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { StringBuffer buf = new StringBuffer (); for (int i = 0; i < mElements.length; i++) { Object elem = mElements [i]; if (elem instanceof String) { buf.append ((String) elem); } else if (elem instanceof Expression) { buf.append ("${"); buf.append (((Expression) elem).getExpressionString ()); buf.append ("}"); } } return buf.toString (); }
/** * * Evaluates to the literal value **/ public Object evaluate (VariableResolver pResolver, FunctionMapper functions, Logger pLogger) throws ELException { Object value = mExpression.evaluate (pResolver, functions, pLogger); if (mOperator != null) { value = mOperator.apply (value, pLogger); } else { for (int i = mOperators.size () - 1; i >= 0; i--) { UnaryOperator operator = (UnaryOperator) mOperators.get (i); value = operator.apply (value, pLogger); } } return value; }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { StringBuffer buf = new StringBuffer (); buf.append (mPrefix.getExpressionString ()); for (int i = 0; mSuffixes != null && i < mSuffixes.size (); i++) { ValueSuffix suffix = (ValueSuffix) mSuffixes.get (i); buf.append (suffix.getExpressionString ()); } return buf.toString (); }
/** * * Evaluates to the literal value **/ public Object evaluate (VariableResolver pResolver, FunctionMapper functions, Logger pLogger) throws ELException { Object value = mExpression.evaluate (pResolver, functions, pLogger); for (int i = 0; i < mOperators.size (); i++) { BinaryOperator operator = (BinaryOperator) mOperators.get (i); // For the And/Or operators, we need to coerce to a boolean // before testing if we shouldEvaluate if (operator.shouldCoerceToBoolean ()) { value = Coercions.coerceToBoolean (value, pLogger); } if (operator.shouldEvaluate (value)) { Expression expression = (Expression) mExpressions.get (i); Object nextValue = expression.evaluate (pResolver, functions, pLogger); value = operator.apply (value, nextValue, pLogger); } } return value; }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { StringBuffer buf = new StringBuffer (); buf.append ("("); buf.append (mExpression.getExpressionString ()); for (int i = 0; i < mOperators.size (); i++) { BinaryOperator operator = (BinaryOperator) mOperators.get (i); Expression expression = (Expression) mExpressions.get (i); buf.append (" "); buf.append (operator.getOperatorSymbol ()); buf.append (" "); buf.append (expression.getExpressionString ()); } buf.append (")"); return buf.toString (); }
public Object evaluate(Object base, VariableResolver resolver, FunctionMapper mapper, Logger logger) throws ELException { if (base == null) { return null; } Object indexValue = getIndex().evaluate(resolver, mapper, logger); if (indexValue == null) { return null; } Integer index = processor_.toIndex(base, indexValue); return PropertyResolverUtil.getValue(application_, base, indexValue, index); }
/** * * Returns the expression in the expression language syntax **/ public String getExpressionString () { StringBuffer buf = new StringBuffer (); buf.append ("("); if (mOperator != null) { buf.append (mOperator.getOperatorSymbol ()); buf.append (" "); } else { for (int i = 0; i < mOperators.size (); i++) { UnaryOperator operator = (UnaryOperator) mOperators.get (i); buf.append (operator.getOperatorSymbol ()); buf.append (" "); } } buf.append (mExpression.getExpressionString ()); buf.append (")"); return buf.toString (); }
for (int i = 0; i < params.length; i++) { arguments[i] = ((Expression) argumentList.get(i)).evaluate(pResolver, functions, pLogger);
/** * * Parses the given expression string, then converts it back to a * String in its canonical form. This is used to test parsing. **/ public String parseAndRender (String pExpressionString) throws ELException { Object val = parseExpressionString (pExpressionString); if (val instanceof String) { return (String) val; } else if (val instanceof Expression) { return "${" + ((Expression) val).getExpressionString () + "}"; } else if (val instanceof ExpressionString) { return ((ExpressionString) val).getExpressionString (); } else { return ""; } }
public Object evaluate(FacesContext context, Object expression) throws EvaluationException { try { VariableResolver resolver = new ELVariableResolver(context); if (expression instanceof Expression) { return ((Expression) expression).evaluate(resolver, mapper_, CommonsElLogger.getLogger()); } else if (expression instanceof ExpressionString) { return ((ExpressionString) expression).evaluate(resolver, mapper_, CommonsElLogger.getLogger()); } } catch (ELException e) { throw new EvaluationException(e); } return null; }
if (base == null) { throw new PropertyNotFoundException("Base is null: " + complexValue.getPrefix().getExpressionString()); if (index == null) { throw new PropertyNotFoundException("Index is null: " + arraySuffixIndex.getExpressionString());
((Expression) parsedValue).evaluate (pResolver, functions, pLogger);