org.apache.commons.jexl2.JexlEngine Java Examples

private HashSet<String> createFilterKeysFromEdgeDefinitions(List<EdgeDefinition> edges) {
    long start = System.currentTimeMillis();
    JexlEngine engine = new JexlEngine();
    Script script;
    HashSet<String> filterFields = new HashSet<>();
    for (EdgeDefinition edgeDef : edges) {
        if (edgeDef.hasJexlPrecondition()) {
            
            script = engine.createScript(edgeDef.getJexlPrecondition());
            filterFields.addAll(extractTermsFromJexlScript(script));
        }
    }
    
    if (log.isTraceEnabled()) {
        log.trace("Time to create filtered keys from edge definitions: " + (System.currentTimeMillis() - start) + "ms.");
    }
    
    return filterFields;
}
 

/**
 * Evaluate a JEXL expression.
 * @param expr expression
 * @param ctx context for the expression
 * @return evaluation result
 */
public Object evalExpression(String expr, Map<String, Object> ctx) {
    JexlEngine jexl = new JexlEngine();

    // Create an expression
    Expression jexlExpr = jexl.createExpression(expr);

    // Create a context and add data
    JexlContext jc = new MapContext(ctx);
    try {
        return jexlExpr.evaluate(jc);
    }
    catch (JexlException e) {
        LOG.error("Error evaluating expression: " + expr, e);
        throw new RuntimeException(e);
    }
}
 

public static void main(String[] args) {
    // Create or retrieve an engine
    JexlEngine jexl = new JexlEngine();

    // Create an expression
    String jexlExp = "Convertor.convert(foo.bar())"; //wrong
    Expression e = jexl.createExpression(jexlExp);

    // Create a context and add data
    JexlContext jc = new MapContext();
    jc.set("foo", new Foo());
    jc.set("Convertor","com.heaven7.java.data.mediator.test.jexl.Convertor");

    // Now evaluate the expression, getting the result
    Object o = e.evaluate(jc);
    System.out.println(0);
}
 

public PartitionExpression(String expression, boolean isStrict) {
  this.engine = new JexlEngine();
  Map<String, Object> fns = new HashMap<String, Object>();
  fns.put(null, PartitionFunctions.class);
  this.engine.setFunctions(fns);
  this.engine.setStrict(true);
  this.engine.setSilent(false);
  this.engine.setCache(10);
  this.expression = engine.createExpression(expression);
  this.isStrict = isStrict;
}
 

/**
 * Creates a preconfigured JexlEngine.
 * <p>The instance is configured to use function namespaces from {@link scriptella.core.EtlVariable}.
 *
 * @return instance of JexlEngine.
 */
public static JexlEngine newJexlEngine() {
    JexlEngine je = new JexlEngine();
    Map<String, Object> fMap = new HashMap<String, Object>();
    EtlVariable etl = new EtlVariable();
    fMap.put("date", etl.getDate());
    fMap.put("text", etl.getText());
    fMap.put("class", etl.getClazz());
    je.setFunctions(fMap);
    return je;
}
 

/**
 * 条件执行器
 *
 * @param exp
 * @param args
 * @return
 */
private static boolean convertToCode(String exp, Map<String, Object> args) {
    JexlEngine engine = new JexlEngine();
    Expression expression = engine.createExpression(exp);
    JexlContext context = new MapContext();
    args.forEach(context::set);
    return (boolean) expression.evaluate(context);
}
 

public JexlEngine getEngine() {
    return engine;
}
 

private void createEngine() {
    this.setEngine(new JexlEngine(null, new MultiMapArithmetic(false), null, null));
    this.getEngine().setDebug(false); // Turn off debugging to make things go faster
    this.getEngine().setCache(50); // Set cache size lower than default value of 512
}
 

public void keyReleased(KeyEvent ke){
	String txt = text.getText();
	
	// We have a formula, if the string starts with "="
	if (txt.startsWith("=")) {
		String formula;
		if (txt.contains(";")) {
			formula = txt.substring(1, txt.indexOf(";"));
			
			Map<String, Object> functions = new HashMap<>();
			functions.put("math", Math.class);
			JexlEngine jexl = new JexlEngine();
			jexl.setLenient(false);
			jexl.setFunctions(functions);
			
			try {
				Expression expr = jexl.createExpression(formula);
				Object result = expr.evaluate(new MapContext());
				text.setText("");
				text.setMessage(formula + "=" + result + "");
				result = null;
			} catch (JexlException e) {
				text.setText("");
				text.setMessage("Invalid expression: " + formula);
			}
		}
		return;
	}
	
	if (txt.length() > 1) {
		filterPositionTitle.setSearchText(txt);
		viewer.getControl().setRedraw(false);
		viewer.refresh();
		viewer.getControl().setRedraw(true);
	} else {
		filterPositionTitle.setSearchText(null);
		viewer.getControl().setRedraw(false);
		viewer.refresh();
		viewer.getControl().setRedraw(true);
	}
}
 

public ExpressionLanguageJEXLImpl() {
    this(new JexlEngine());
}
 

public ExpressionLanguageJEXLImpl() {
    this(new JexlEngine());
    this.jexlEngine.setLenient(true);
    this.jexlEngine.setSilent(true);
}
 

NormalizedExpression(JexlEngine engine, String query, ASTJexlScript script) {
    super(engine, query, script);
}
 

public void setEngine(JexlEngine engine) {
    this.engine = engine;
}
 

public DatawaveInterpreter(JexlEngine jexl, JexlContext aContext, boolean strictFlag, boolean silentFlag) {
    super(jexl, aContext, strictFlag, silentFlag);
    resultMap = Maps.newHashMap();
}
 

public ExpressionEvaluatorImpl(@NonNull JexlEngine jexl) {
    this.jexl = jexl;
}
 

@Provides
@Singleton
RuleExpressionEvaluator ruleExpressionEvaluator(@NonNull JexlEngine jexlEngine) {
    return new ExpressionEvaluatorImpl(jexlEngine);
}
 

@Provides
@Singleton
JexlEngine jexlEngine() {
    return new JexlEngine();
}
 

/**
 * @param expression the expression.
 * @param vars the variables, can be null.
 * @param strict indicates whether to use strict or lenient engine mode.
 * @return the result of the evaluation.
 */
private static Object evaluate( String expression, Map<String, Object> vars, boolean strict )
{
    expression = expression.replaceAll( IGNORED_KEYWORDS_REGEX, StringUtils.EMPTY );

    JexlEngine engine = strict ? JEXL_STRICT : JEXL;

    Expression exp = engine.createExpression( expression );

    JexlContext context = vars != null ? new MapContext( vars ) : new MapContext();

    return exp.evaluate( context );
}
 

/**
 * @param expression the expression.
 * @param vars       the variables, can be null.
 * @param strict     indicates whether to use strict or lenient engine mode.
 * @return the result of the evaluation.
 */
private static Object evaluate(String expression, Map<String, Object> vars, boolean strict) {
    String formattedExpression = expression.replaceAll(IGNORED_KEYWORDS_REGEX, StringUtils.EMPTY);

    JexlEngine engine = strict ? JEXL_STRICT : JEXL;

    Expression exp = engine.createExpression(formattedExpression);

    JexlContext context = vars == null ? new MapContext() : new MapContext(vars);

    return exp.evaluate(context);
}
 

/**
 * {@link JexlEngine}を指定するコンストラクタ。
 * @param jexlEngine JEXLの処理エンジン。
 */
public ExpressionLanguageJEXLImpl(final JexlEngine jexlEngine) {
    this.jexlEngine = jexlEngine;
}
 

/**
 * {@link JexlEngine}を取得する。
 * @return
 */
public JexlEngine getJexlEngine() {
    return jexlEngine;
}
 

/**
 * {@link JexlEngine}を指定するコンストラクタ。
 * @param jexlEngine JEXLの処理エンジン。
 */
public ExpressionLanguageJEXLImpl(final JexlEngine jexlEngine) {
    this.jexlEngine = jexlEngine;
}
 

/**
 * {@link JexlEngine}を取得する。
 * @return
 */
public JexlEngine getJexlEngine() {
    return jexlEngine;
}