Notify interested listeners that an expression will be evaluated.

@param expression The expression that will be evaluated

@since EL 3.0
12633
public void notifyBeforeEvaluation(String expression) {
        for (EvaluationListener listener : listeners) {
            try {
                listener.beforeEvaluation(this, expression);
            } catch (Throwable t) {
                Util.handleThrowable(t);
                // Ignore - no option to log
            }
        }
    }
54388
private void resolveStaticMethodsUsingImports(Expression expression) {
    if (expression instanceof MethodCallExpr) {
      MethodCallExpr methodCall = ((MethodCallExpr) expression);
      String methodName = methodCall.getName().getIdentifier();
      if (!methodCall.getScope().isPresent() && context.hasStaticMethod(methodName)) {
        methodCall.setName(context.getFullyQualifiedNameForMethodName(methodName));
      }
    }

    // Recurse downward in the expression
    expression
        .getChildNodes()
        .stream()
        .filter(Expression.class::isInstance)
        .map(Expression.class::cast)
        .forEach(this::resolveStaticMethodsUsingImports);
  }
1272716
public void notifyBeforeEvaluation(String expr) {
        if (getEvaluationListeners() == null)
            return;
        for (EvaluationListener listener: getEvaluationListeners()) {
            listener.beforeEvaluation(this, expr);
        }
    }
878554
@RestrictTo(LIBRARY)
	public void notifyFinishedUseCase(UseCaseListener listener) {
		try {
			LOGGER.debug("Notifying " + getClass().getSimpleName() + " finish to listener " + listener.getClass().getSimpleName());
			listener.onFinishUseCase();
		} catch (Exception e) {
			AbstractException abstractException = wrapException(e);
			logHandledException(abstractException);
		}
	}
490884
private Object eval(Bindings bindings, String expression) {
    try {
      return jsScriptEngine.eval(bindings, expression);
    } catch (javax.script.ScriptException t) {
      return new ScriptException(t.getCause().getMessage(), t.getCause());
    } catch (Exception t) {
      return new ScriptException(t);
    }
  }
1228470
private boolean passesExpression(LoggingEvent event) {
    if (event != null) {
      if (expressionRule != null) {
        return (expressionRule.evaluate(event, null));
      }
    }
    return true;
  }
1252493
public void addEvaluationListener(EvaluationListener listener) {
        if (listeners == null) {
            listeners = new ArrayList<EvaluationListener>();
        }
        listeners.add(listener);
    }
672194
private void appendExpression(final BooleanExpression newExpression) {
		if (lhsExpression != null) {
			throw new SyntaxException("Syntax exception: use AND or OR to join expressions");
		}

		lhsExpression = newExpression;

		GroupExpression currentExpression = stack.isEmpty() ? null : stack.peek();

		if (currentExpression == null) {
			this.expression.setExpression(newExpression);
		} else {
			currentExpression.add(newExpression);
		}
	}
760609
private void checkForFinal(final Expression expression, VariableExpression ve) {
        Variable v = ve.getAccessedVariable();
        boolean isFinal = isFinal(v.getModifiers());
        boolean isParameter = v instanceof Parameter;
        if (isFinal && isParameter) {
            addError("Cannot assign a value to final variable '" + v.getName() + "'", expression);
        }
    }
1092369
@NonNull
    public static SortOrder expression(@NonNull Expression expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression cannot be null.");
        }
        return new SortOrder(expression);
    }
430710
protected void notifyListeners(IQueryFilter<T> filter) {
        for (IQueryFilterChanged<T> listener : listeners) {
            listener.onFilterChanged(filter);
        }
    }
1372054
@Override
  public void setFilter(@NonNull Expression expression) {
    layerFilter = expression;
    layer.setFilter(layerFilter);
  }
64963
public static Statement returnExpression(final Expression expression) {
    // TODO(lukes): it would be nice to do a checkType operation here to make sure that expression
    // is compatible with the return type of the method, but i don't know how to get that
    // information here (reasonably).  So it is the caller's responsibility.
    return new Statement() {
      @Override
      protected void doGen(CodeBuilder adapter) {
        expression.gen(adapter);
        adapter.returnValue();
      }
    };
  }
404188
protected void diagnoseLineNumber(Expression expr)
  {
    ElemTemplateElement e = getElemFromExpression(expr);
    System.err.println("   " + e.getSystemId() + " Line " + e.getLineNumber());
  }
456639
@Override
    public void checkListener(Object listener)
    {
        if (listener instanceof SelectionListener)
        {
            selector.addListener((SelectionListener) listener);
        }
    }
127206
@Check
	public void checkAssumeKeywordUse(SarlAssertExpression expression) {
		if (expression.isIsStatic()) {
			error(MessageFormat.format(
					Messages.SARLValidator_0,
					this.grammarAccess.getIsStaticAssumeKeyword()),
					expression,
					null);
		}
	}
1335707
public void addSelectionChangedListener(ISelectionChangedListener listener)
	{
		if (fOutlineViewer != null)
		{
			fOutlineViewer.addSelectionChangedListener(listener);
		} else
		{
			fSelectionChangedListeners.add(listener);
		}
	}