import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * Evaluate an expression.
 *
 * @param ctx variable context
 * @param expr expression
 * @return a result of the evaluation
 * @throws SCXMLExpressionException For a malformed expression
 * @see Evaluator#eval(Context, String)
 */
public Object eval(final Context ctx, final String expr)
throws SCXMLExpressionException {
    if (expr == null) {
        return null;
    }
    if (!(ctx instanceof JexlContext)) {
        throw new SCXMLExpressionException(ERR_CTX_TYPE);
    }
    try {
        final JexlContext effective = getEffectiveContext((JexlContext)ctx);
        JexlExpression exp = getJexlEngine().createExpression(expr);
        return exp.evaluate(effective);
    } catch (Exception e) {
        String exMessage = e.getMessage() != null ? e.getMessage() : e.getClass().getCanonicalName();
        throw new SCXMLExpressionException("eval('" + expr + "'): " + exMessage, e);
    }
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * @see Evaluator#evalCond(Context, String)
 */
public Boolean evalCond(final Context ctx, final String expr)
throws SCXMLExpressionException {
    if (expr == null) {
        return null;
    }
    if (!(ctx instanceof JexlContext)) {
        throw new SCXMLExpressionException(ERR_CTX_TYPE);
    }
    try {
        final JexlContext effective = getEffectiveContext((JexlContext)ctx);
        JexlExpression exp = getJexlEngine().createExpression(expr);
        final Object result = exp.evaluate(effective);
        return result == null ? Boolean.FALSE : (Boolean)result;
    } catch (Exception e) {
        String exMessage = e.getMessage() != null ? e.getMessage() : e.getClass().getCanonicalName();
        throw new SCXMLExpressionException("evalCond('" + expr + "'): " + exMessage, e);
    }
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
public static String evaluate(final String expression, final JexlContext jexlContext) {
    String result = StringUtils.EMPTY;

    if (StringUtils.isNotBlank(expression) && jexlContext != null) {
        try {
            JexlExpression jexlExpression = getEngine().createExpression(expression);
            Object evaluated = jexlExpression.evaluate(jexlContext);
            if (evaluated != null) {
                result = evaluated.toString();
            }
        } catch (Exception e) {
            LOG.error("Error while evaluating JEXL expression: " + expression, e);
        }
    } else {
        LOG.debug("Expression not provided or invalid context");
    }

    return result;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
@Override
public MatchResult match(IData idata) {
	JexlContext ctx = new IDataJexlContext(idata);
	for (Entry<String, JexlExpression> expr : expressions.entrySet()) {
		Object result = expr.getValue().evaluate(ctx);
		verifyExpressionResult(expr.getKey(), result);
		if ((Boolean) result)
			return new MatchResult(true, expr.getKey());
	}
	return MatchResult.FALSE;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
@Override
public Map<String, Object> toMap() {
	Map<String, Object> am = new HashMap<>();
	am.put("type", "JexlIDataMatcher");
	for (Entry<String, JexlExpression> e : expressions.entrySet()) {
		am.put(e.getKey(), e.getValue().toString());
	}
	return am;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
@Override
protected void execute(ExecutionContext executionContext) throws Exception {
	IData idata = executionContext.getPipeline();
	for (JexlExpression expression : expressions) {
		expression.evaluate(new IDataJexlContext(idata));
	}
	executionContext.setPipeline(idata);
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
private boolean evaluateVisibility(Object object,
    PropertyDescriptor[] beanPropertyDescriptors, String visibleWhen)
{
  Map<String, PropertyDescriptor> descriptorsMap =
      new HashMap<String, PropertyDescriptor>();
  for (PropertyDescriptor pd : beanPropertyDescriptors)
  {
    descriptorsMap.put(pd.getName(), pd);
  }

  JexlEngine jexl = new JexlBuilder().create();
  JexlExpression expression = jexl.createExpression(visibleWhen);
  JexlContext context = new MapContext();

  Set<List<String>> vars = ((Script) expression).getVariables();
  for (List<String> varList : vars)
  {
    for (String varName : varList)
    {
      PropertyDescriptor propertyDescriptor = descriptorsMap.get(varName);
      if (propertyDescriptor != null)
      {
        try
        {
          Object value = propertyDescriptor.getReadMethod().invoke(object);
          context.set(varName, value);
        }
        catch (Exception e)
        {
          Activator.logError(Status.ERROR,
              "Could not retrieve value for property " + varName, e);
        }
      }
    }
  }

  return (boolean) expression.evaluate(context);
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
public MapBasedRow(Map<String, String> data, Map<String, List<String>> joinedData, ErrorHandler errorHandler,
                   Map<String, JexlExpression> expressions) {
  this.data = data;
  this.joinedData = joinedData;
  this.errorHandler = errorHandler;
  this.expressions = expressions;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * Position the debugger on the root of an expression.
 * @param jscript the expression
 * @return true if the expression was a {@link Script} instance, false otherwise
 */
public boolean debug(JexlExpression jscript) {
    if (jscript instanceof Script) {
        return debug(((Script) jscript).script);
    } else {
        return false;
    }
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * Visits all AST constituents of a JEXL expression.
 * @param jscript the expression
 * @param data some data context
 * @return the visit result or null if jscript was not a Script implementation
 */
public Object visitExpression (JexlExpression jscript, Object data) {
    if (jscript instanceof Script) {
        return ((Script) jscript).getScript().jjtAccept(this, data);
    }
    return null;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * An example for array access.
 */
static void example(Output out) throws Exception {
    /**
     * First step is to retrieve an instance of a JexlEngine;
     * it might be already existing and shared or created anew.
     */
    JexlEngine jexl = new JexlBuilder().create();
    /*
     *  Second make a jexlContext and put stuff in it
     */
    JexlContext jc = new MapContext();

    List<Object> l = new ArrayList<Object>();
    l.add("Hello from location 0");
    Integer two = new Integer(2);
    l.add(two);
    jc.set("array", l);

    JexlExpression e = jexl.createExpression("array[1]");
    Object o = e.evaluate(jc);
    out.print("Object @ location 1 = ", o, two);

    e = jexl.createExpression("array[0].length()");
    o = e.evaluate(jc);

    out.print("The length of the string at location 0 is : ", o, Integer.valueOf(21));
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
private JexlExpression createExpression(String name, String exprText) {
	JexlExpression compiledExpr = JexlExpressionFactory.createExpression(exprText);
	Object result = compiledExpr.evaluate(new MapContext());
	verifyExpressionResult(name, result);
	return compiledExpr;
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
private void createExpression(String name, String exprText) {
	JexlExpression compiledExpr = JexlExpressionFactory.createExpression(exprText);
	Object result = compiledExpr.evaluate(new MapContext());
	verifyExpressionResult(name, result);
	expressions.put(name, compiledExpr);
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
public JexlSelector(final String expression) {
  this.expression = isNullOrEmpty(expression) ? Optional.<JexlExpression>empty()
      : Optional.of(threadLocalJexl.get().createExpression(CALLER_INFO, expression));
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
public String getSourceText() {
  return expression.map(JexlExpression::getSourceText).orElse("");
}
 

import org.apache.commons.jexl3.JexlExpression; //导入依赖的package包/类
/**
 * An example for method access.
 */
public static void example(final Output out) throws Exception {
    /**
     * First step is to retrieve an instance of a JexlEngine;
     * it might be already existing and shared or created anew.
     */
    JexlEngine jexl = new JexlBuilder().create();
    /*
     *  Second make a jexlContext and put stuff in it
     */
    JexlContext jc = new MapContext();

    /**
     * The Java equivalents of foo and number for comparison and checking
     */
    Foo foo = new Foo();
    Integer number = new Integer(10);

    jc.set("foo", foo);
    jc.set("number", number);

    /*
     *  access a method w/o args
     */
    JexlExpression e = jexl.createExpression("foo.getFoo()");
    Object o = e.evaluate(jc);
    out.print("value returned by the method getFoo() is : ", o, foo.getFoo());

    /*
     *  access a method w/ args
     */
    e = jexl.createExpression("foo.convert(1)");
    o = e.evaluate(jc);
    out.print("value of " + e.getParsedText() + " is : ", o, foo.convert(1));

    e = jexl.createExpression("foo.convert(1+7)");
    o = e.evaluate(jc);
    out.print("value of " + e.getParsedText() + " is : ", o, foo.convert(1+7));

    e = jexl.createExpression("foo.convert(1+number)");
    o = e.evaluate(jc);
    out.print("value of " + e.getParsedText() + " is : ", o, foo.convert(1+number.intValue()));

    /*
     * access a property
     */
    e = jexl.createExpression("foo.bar");
    o = e.evaluate(jc);
    out.print("value returned for the property 'bar' is : ", o, foo.get("bar"));

}