public static EvalMatchUntilStateBounds InitBounds(
EvalMatchUntilFactoryNode factoryNode,
MatchedEventMap beginState,
PatternAgentInstanceContext context)
{
int? lowerbounds = null;
int? upperbounds = null;
var convertor = factoryNode.OptionalConvertor;
var eventsPerStream = convertor == null ? null : convertor.Invoke(beginState);
if (factoryNode.SingleBound != null) {
var bounds = (int?) factoryNode.SingleBound.Evaluate(
eventsPerStream,
true,
context.AgentInstanceContext);
lowerbounds = bounds;
upperbounds = bounds;
}
else {
if (factoryNode.LowerBounds != null) {
lowerbounds = (int?) factoryNode.LowerBounds.Evaluate(
eventsPerStream,
true,
context.AgentInstanceContext);
}
if (factoryNode.UpperBounds != null) {
upperbounds = (int?) factoryNode.UpperBounds.Evaluate(
eventsPerStream,
true,
context.AgentInstanceContext);
}
if (upperbounds != null && lowerbounds != null) {
if (upperbounds < lowerbounds) {
var lbounds = lowerbounds;
lowerbounds = upperbounds;
upperbounds = lbounds;
}
}
}
return new EvalMatchUntilStateBounds(lowerbounds, upperbounds);
}
public long ComputeDelta(MatchedEventMap beginState, PatternAgentInstanceContext context)
{
if (_parameter is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod)_parameter;
return(timePeriod.NonconstEvaluator()
.DeltaUseEngineTime(_convertor.Convert(beginState), context.AgentInstanceContext));
}
else
{
var result = _parameter.ExprEvaluator.Evaluate(
new EvaluateParams(_convertor.Convert(beginState), true, context.AgentInstanceContext));
if (result == null)
{
throw new EPException("Null value returned for guard expression");
}
return(context.StatementContext.TimeAbacus.DeltaForSecondsNumber(result));
}
}
public long ComputeTime(MatchedEventMap beginState, PatternAgentInstanceContext context)
{
if (_timeExpr is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod) _timeExpr;
return timePeriod.NonconstEvaluator()
.DeltaUseEngineTime(_convertor.Convert(beginState), context.AgentInstanceContext);
}
else
{
Object time = PatternExpressionUtil.Evaluate(
"Timer-Within-Or-Max-Count guard", beginState, _timeExpr, _convertor, context.AgentInstanceContext);
if (null == time)
{
throw new EPException("Timer-within-or-max first parameter evaluated to a null-value");
}
return context.StatementContext.TimeAbacus.DeltaForSecondsNumber(time);
}
}
public long ComputeMilliseconds(MatchedEventMap beginState, PatternAgentInstanceContext context)
{
if (_millisecondsExpr is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod)_millisecondsExpr;
return(timePeriod.NonconstEvaluator().DeltaMillisecondsUseEngineTime(
_convertor.Convert(beginState), context.AgentInstanceContext));
}
else
{
var millisecondVal = PatternExpressionUtil.Evaluate(
"Timer-Within-Or-Max-Count guard", beginState, _millisecondsExpr, _convertor, context.AgentInstanceContext);
if (null == millisecondVal)
{
throw new EPException("Timer-within-or-max first parameter evaluated to a null-value");
}
return((long)Math.Round(1000d * millisecondVal.AsDouble()));
}
}
public EventObserver MakeObserver(
PatternAgentInstanceContext context,
MatchedEventMap beginState,
ObserverEventEvaluator observerEventEvaluator,
object observerState,
bool isFilterChildNonQuitting)
{
var events = convertor == null ? null : convertor.Invoke(beginState);
var filename = PatternExpressionUtil.EvaluateChecked(
"File-exists observer ",
filenameExpression,
events,
context.AgentInstanceContext);
if (filename == null) {
throw new EPException("Filename evaluated to null");
}
return new MyFileExistsObserver(beginState, observerEventEvaluator, filename.ToString());
}
public Guard MakeGuard(
PatternAgentInstanceContext context,
MatchedEventMap beginState,
Quitable quitable,
object guardState)
{
var events = Convertor == null ? null : Convertor.Invoke(beginState);
var parameter = PatternExpressionUtil.EvaluateChecked(
"Count-to guard",
NumCountToExpr,
events,
context.AgentInstanceContext);
if (parameter == null) {
throw new EPException("Count-to guard parameter evaluated to a null value");
}
var numCountTo = parameter.AsInt32();
return new MyCountToPatternGuard(numCountTo, quitable);
}
public long ComputeTime(MatchedEventMap beginState, PatternAgentInstanceContext context)
{
if (_timeExpr is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod)_timeExpr;
return(timePeriod.NonconstEvaluator()
.DeltaUseEngineTime(_convertor.Convert(beginState), context.AgentInstanceContext));
}
else
{
var time = PatternExpressionUtil.Evaluate(
"Timer-within guard", beginState, _timeExpr, _convertor, context.AgentInstanceContext);
if (time == null)
{
throw new EPException("Timer-within guard expression returned a null-value");
}
return(context.StatementContext.TimeAbacus.DeltaForSecondsNumber(time));
}
}
public void Activate(EventBean optionalTriggeringEvent, MatchedEventMap priorMatches, long timeOffset, bool isRecoveringResilient)
{
if (PatternStopCallback != null)
{
PatternStopCallback.Stop();
}
PatternStreamSpecCompiled patternStreamSpec = _endpointPatternSpec.PatternCompiled;
StatementContext stmtContext = _agentInstanceContext.StatementContext;
EvalRootFactoryNode rootFactoryNode = _servicesContext.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode);
int streamNum = _isStartEndpoint ? _contextStatePathKey.SubPath : -1 * _contextStatePathKey.SubPath;
bool allowResilient = _contextStatePathKey.Level == 1;
PatternContext patternContext = stmtContext.PatternContextFactory.CreateContext(stmtContext, streamNum, rootFactoryNode, new MatchedEventMapMeta(patternStreamSpec.AllTags, !patternStreamSpec.ArrayEventTypes.IsEmpty()), allowResilient);
PatternAgentInstanceContext patternAgentInstanceContext = stmtContext.PatternContextFactory.CreatePatternAgentContext(patternContext, _agentInstanceContext, false);
EvalRootNode rootNode = EvalNodeUtil.MakeRootNodeFromFactory(rootFactoryNode, patternAgentInstanceContext);
if (priorMatches == null)
{
priorMatches = new MatchedEventMapImpl(patternContext.MatchedEventMapMeta);
}
// capture any callbacks that may occur right after start
ConditionPatternMatchCallback callback = new ConditionPatternMatchCallback(this);
PatternStopCallback = rootNode.Start(callback.MatchFound, patternContext, priorMatches, isRecoveringResilient);
callback.ForwardCalls = true;
if (_agentInstanceContext.StatementContext.StatementExtensionServicesContext != null &&
_agentInstanceContext.StatementContext.StatementExtensionServicesContext.StmtResources != null)
{
_agentInstanceContext.StatementContext.StatementExtensionServicesContext.StmtResources
.StartContextPattern(PatternStopCallback, _isStartEndpoint, _contextStatePathKey);
}
if (callback.IsInvoked)
{
MatchFound(Collections.GetEmptyMap <String, Object>());
}
}
public long ComputeMilliseconds(MatchedEventMap beginState, PatternAgentInstanceContext context)
{
if (MillisecondsExpr is ExprTimePeriod)
{
ExprTimePeriod timePeriod = (ExprTimePeriod)MillisecondsExpr;
return(timePeriod.NonconstEvaluator()
.DeltaMillisecondsUseEngineTime(Convertor.Convert(beginState), context.AgentInstanceContext));
}
else
{
Object millisecondVal = PatternExpressionUtil.Evaluate(
"Timer-within guard", beginState, MillisecondsExpr, Convertor, context.AgentInstanceContext);
if (millisecondVal == null)
{
throw new EPException("Timer-within guard expression returned a null-value");
}
return((long)Math.Round(1000d * millisecondVal.AsDouble()));
}
}
public bool Activate(
EventBean optionalTriggeringEvent,
ContextControllerEndConditionMatchEventProvider endConditionMatchEventProvider,
IDictionary<string, object> optionalTriggeringPattern)
{
patternStopCallback?.Stop();
var agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
Func<FilterSpecActivatable, FilterValueSetParam[][]> contextAddendumFunction = filter =>
ContextManagerUtil.ComputeAddendumNonStmt(partitionKeys, filter, controller.Realization);
var patternAgentInstanceContext = new PatternAgentInstanceContext(
pattern.PatternContext,
agentInstanceContext,
false,
contextAddendumFunction);
var rootNode = EvalNodeUtil.MakeRootNodeFromFactory(pattern.Pattern, patternAgentInstanceContext);
var matchedEventMap = new MatchedEventMapImpl(pattern.PatternContext.MatchedEventMapMeta);
if (optionalTriggeringEvent != null) {
endConditionMatchEventProvider?.PopulateEndConditionFromTrigger(
matchedEventMap,
optionalTriggeringEvent);
}
if (optionalTriggeringPattern != null) {
endConditionMatchEventProvider?.PopulateEndConditionFromTrigger(matchedEventMap, optionalTriggeringPattern);
}
// capture any callbacks that may occur right after start
var callback = new ConditionPatternMatchCallback(this);
patternStopCallback = rootNode.Start(callback, pattern.PatternContext, matchedEventMap, false);
callback.forwardCalls = true;
if (callback.IsInvoked) {
MatchFound(Collections.GetEmptyMap<string, object>(), optionalTriggeringEvent);
}
return false;
}
public override EvalNode MakeEvalNode(
PatternAgentInstanceContext agentInstanceContext,
EvalNode parentNode)
{
return new EvalObserverNode(agentInstanceContext, this);
}
public SupportQuitable(PatternAgentInstanceContext patternContext)
{
_patternContext = patternContext;
}
public abstract EvalNode MakeEvalNode(
PatternAgentInstanceContext agentInstanceContext,
EvalNode parentNode);
/// <summary> /// Constructs a guard instance. /// </summary> /// <param name="context">services for use by guard</param> /// <param name="beginState">the prior matching events</param> /// <param name="quitable">to use for indicating the guard has quit</param> /// <param name="stateNodeId">a node id for the state object</param> /// <param name="guardState">state node for guard</param> /// <returns> /// guard instance /// </returns> public abstract Guard MakeGuard(PatternAgentInstanceContext context, MatchedEventMap beginState, Quitable quitable, EvalStateNodeNumber stateNodeId, object guardState);
public static EvalRootNode MakeRootNodeFromFactory(
EvalRootFactoryNode rootFactoryNode,
PatternAgentInstanceContext patternAgentInstanceContext)
{
return((EvalRootNode)rootFactoryNode.MakeEvalNode(patternAgentInstanceContext, null));
}
public EvalAuditNode(PatternAgentInstanceContext context, EvalAuditFactoryNode factoryNode, EvalNode childNode)
: base(context)
{
_factoryNode = factoryNode;
_childNode = childNode;
}
public void SetUp()
{
_patternContext = SupportPatternContextFactory.MakePatternAgentInstanceContext();
}
public Guard MakeGuard(PatternAgentInstanceContext context, MatchedEventMap beginState, Quitable quitable, EvalStateNodeNumber stateNodeId, Object guardState)
{
return(new ExpressionGuard(Convertor, Expression.ExprEvaluator, quitable));
}
public EvalObserverNode(PatternAgentInstanceContext context, EvalObserverFactoryNode factoryNode)
: base(context)
{
_factoryNode = factoryNode;
}
protected EvalNodeBase(PatternAgentInstanceContext context)
{
Context = context;
}
public EvalOrNode(PatternAgentInstanceContext context, EvalOrFactoryNode factoryNode, EvalNode[] childNodes)
: base(context)
{
FactoryNode = factoryNode;
ChildNodes = childNodes;
}
public Guard MakeGuard(PatternAgentInstanceContext context, MatchedEventMap beginState, Quitable quitable, EvalStateNodeNumber stateNodeId, Object guardState)
{
return(null);
}
public Guard MakeGuard(PatternAgentInstanceContext context, MatchedEventMap matchedEventMap, Quitable quitable, EvalStateNodeNumber stateNodeId, Object guardState)
{
return(new TimerWithinGuard(ComputeMilliseconds(matchedEventMap, context), quitable));
}
public long AbsExpiry(PatternAgentInstanceContext context)
{
var current = context.StatementContext.SchedulingService.Time;
return current + TimePeriodCompute.DeltaAdd(current, null, true, context.AgentInstanceContext);
}
public SupportObserverEventEvaluator(PatternAgentInstanceContext patternContext)
{
_patternContext = patternContext;
}
public SupportObserverEvaluator(PatternAgentInstanceContext context)
{
_context = context;
}
