public ExpressionGuard(MatchedEventConvertor convertor, ExprEvaluator expression, Quitable quitable)
{
_quitable = quitable;
_convertor = convertor;
_expression = expression;
}
public void SetObserverParameters(IList <ExprNode> observerParameters, MatchedEventConvertor convertor, ExprValidationContext validationContext)
{
}
public override void SetObserverParameters(IList <ExprNode> expressionParameters, MatchedEventConvertor convertor, ExprValidationContext validationContext)
{
const string message = "File exists observer takes a single string filename parameter";
if (expressionParameters.Count != 1)
{
throw new ObserverParameterException(message);
}
if (!(expressionParameters[0].ExprEvaluator.ReturnType == typeof(string)))
{
throw new ObserverParameterException(message);
}
FilenameExpression = expressionParameters[0];
Convertor = convertor;
}
/// <summary>
/// Evaluate the pattern expression.
/// </summary>
/// <param name="objectName">pattern object name</param>
/// <param name="beginState">pattern state</param>
/// <param name="timePeriod">The time period.</param>
/// <param name="convertor">to converting from pattern match to event-per-stream</param>
/// <param name="exprEvaluatorContext">expression evaluation context</param>
/// <returns>
/// evaluation result
/// </returns>
/// <throws>EPException if the evaluation failed</throws>
public static Object EvaluateTimePeriod(String objectName, MatchedEventMap beginState, ExprTimePeriod timePeriod, MatchedEventConvertor convertor, ExprEvaluatorContext exprEvaluatorContext)
{
EventBean[] eventsPerStream = convertor.Convert(beginState);
try {
return(timePeriod.EvaluateGetTimePeriod(new EvaluateParams(eventsPerStream, true, exprEvaluatorContext)));
}
catch (Exception ex)
{
throw HandleRuntimeException(ex, objectName);
}
}
/// <summary>Ctor. </summary>
/// <param name="objectName">is the pattern object name</param>
/// <param name="beginState">the pattern begin state</param>
/// <param name="parameters">object parameters</param>
/// <param name="convertor">for converting to a event-per-stream view for use to evaluate expressions</param>
/// <param name="exprEvaluatorContext">expression evaluation context</param>
/// <returns>expression results</returns>
/// <throws>EPException if the evaluate failed</throws>
public static IList <Object> Evaluate(String objectName, MatchedEventMap beginState, IList <ExprNode> parameters, MatchedEventConvertor convertor, ExprEvaluatorContext exprEvaluatorContext)
{
IList <Object> results = new List <Object>();
var count = 0;
var eventsPerStream = convertor.Convert(beginState);
foreach (var expr in parameters)
{
try
{
var result = Evaluate(objectName, expr, eventsPerStream, exprEvaluatorContext);
results.Add(result);
count++;
}
catch (Exception ex)
{
var message = objectName + " invalid parameter in expression " + count;
if (ex.Message != null)
{
message += ": " + ex.Message;
}
Log.Error(message, ex);
throw new EPException(message);
}
}
return(results);
}
public static Object Evaluate(String objectName, MatchedEventMap beginState, ExprNode parameter, MatchedEventConvertor convertor, ExprEvaluatorContext exprEvaluatorContext)
{
var eventsPerStream = convertor.Convert(beginState);
return(Evaluate(objectName, parameter, eventsPerStream, exprEvaluatorContext));
}
public abstract void SetGuardParameters(IList <ExprNode> guardParameters, MatchedEventConvertor convertor);
/// <summary>
/// Sets the observer object parameters.
/// </summary>
/// <param name="paramList">is a list of parameters</param>
/// <param name="convertor">for converting partial pattern matches to event-per-stream for expressions</param>
/// <param name="validationContext">The validation context.</param>
/// <throws>ObserverParameterException thrown to indicate a parameter problem</throws>
public abstract void SetObserverParameters(
IList <ExprNode> paramList,
MatchedEventConvertor convertor,
ExprValidationContext validationContext);
