public override void ToPrecedenceFreeEPL(TextWriter writer) { if (OptionalMaxExpressions == null || OptionalMaxExpressions.IsEmpty()) { PatternExpressionUtil.ToPrecedenceFreeEPL(writer, "->", ChildNodes, Precedence); } else { ChildNodes[0].ToEPL(writer, PatternExpressionPrecedenceEnum.MINIMUM); for (var i = 1; i < ChildNodes.Count; i++) { ExprNode optionalMaxExpression = null; if (OptionalMaxExpressions.Count > i - 1) { optionalMaxExpression = OptionalMaxExpressions[i - 1]; } if (optionalMaxExpression == null) { writer.Write(" -> "); } else { writer.Write(" -["); writer.Write(ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(optionalMaxExpression)); writer.Write("]> "); } ChildNodes[i].ToEPL(writer, PatternExpressionPrecedenceEnum.MINIMUM); } } }
public int ComputeNumCountTo(MatchedEventMap beginState, PatternAgentInstanceContext context) { Object numCountToVal = PatternExpressionUtil.Evaluate( "Timer-Within-Or-Max-Count guard", beginState, _numCountToExpr, _convertor, context.AgentInstanceContext); if (null == numCountToVal) { throw new EPException("Timer-within-or-max second parameter evaluated to a null-value"); } return numCountToVal.AsInt(); }
public TimerScheduleSpec Compute(MatchedEventConvertor convertor, MatchedEventMap beginState, ExprEvaluatorContext exprEvaluatorContext, TimeZoneInfo timeZone) { object param = PatternExpressionUtil.Evaluate( NAME_OBSERVER, beginState, _parameter, convertor, exprEvaluatorContext); var iso = (string) param; if (iso == null) { throw new ScheduleParameterException("Received null parameter value"); } return TimerScheduleISO8601Parser.Parse(iso); }
public override Guard MakeGuard(PatternAgentInstanceContext context, MatchedEventMap beginState, Quitable quitable, EvalStateNodeNumber stateNodeId, Object guardState) { Object parameter = PatternExpressionUtil.Evaluate("Count-to guard", beginState, _numCountToExpr, _convertor, null); if (parameter == null) { throw new EPException("Count-to guard parameter evaluated to a null value"); } int numCountTo = parameter.AsInt(); return(new MyCountToPatternGuard(numCountTo, quitable)); }
public TimerScheduleSpec Compute(MatchedEventConvertor convertor, MatchedEventMap beginState, ExprEvaluatorContext exprEvaluatorContext, TimeZoneInfo timeZone) { DateTimeEx optionalDate = null; if (_dateNode != null) { object param = PatternExpressionUtil.Evaluate( NAME_OBSERVER, beginState, _dateNode, convertor, exprEvaluatorContext); if (param is string) { optionalDate = TimerScheduleISO8601Parser.ParseDate((string) param); } else if (param.IsLong()) { optionalDate = new DateTimeEx(param.AsDateTimeOffset(timeZone), timeZone); } else if (param.IsInt()) { optionalDate = new DateTimeEx(param.AsDateTimeOffset(timeZone), timeZone); } else if (param is DateTimeOffset || param is DateTime) { optionalDate = new DateTimeEx(param.AsDateTimeOffset(timeZone), timeZone); } } TimePeriod optionalTimePeriod = null; if (_periodNode != null) { object param = PatternExpressionUtil.EvaluateTimePeriod( NAME_OBSERVER, beginState, _periodNode, convertor, exprEvaluatorContext); optionalTimePeriod = (TimePeriod) param; } long? optionalRepeatCount = null; if (_repetitionsNode != null) { object param = PatternExpressionUtil.Evaluate( NAME_OBSERVER, beginState, _repetitionsNode, convertor, exprEvaluatorContext); if (param != null) { optionalRepeatCount = param.AsLong(); } } if (optionalDate == null && optionalTimePeriod == null) { throw new EPException("Required date or time period are both null for " + NAME_OBSERVER); } return new TimerScheduleSpec(optionalDate, optionalRepeatCount, optionalTimePeriod); }
public ScheduleSpec ComputeSpec(MatchedEventMap beginState, PatternAgentInstanceContext context) { if (spec != null) { return(spec); } IList <Object> observerParameters = PatternExpressionUtil.Evaluate("Timer-at observer", beginState, parameters, convertor, context.AgentInstanceContext); try { return(ScheduleSpecUtil.ComputeValues(observerParameters.ToArray())); } catch (ScheduleParameterException e) { throw new EPException("Error computing crontab schedule specification: " + e.Message, e); } }
public void SetObserverParameters( IList <ExprNode> parameters, MatchedEventConvertor convertor, ExprValidationContext validationContext) { ObserverParameterUtil.ValidateNoNamedParameters("timer:at", parameters); if (Log.IsDebugEnabled) { Log.Debug(".setObserverParameters " + parameters); } if ((parameters.Count < 5) || (parameters.Count > 7)) { throw new ObserverParameterException("Invalid number of parameters for timer:at"); } _parameters = parameters; _convertor = convertor; // if all parameters are constants, lets try to evaluate and build a schedule for early validation bool allConstantResult = true; foreach (ExprNode param in parameters) { if (!param.IsConstantResult) { allConstantResult = false; } } if (allConstantResult) { try { var observerParameters = PatternExpressionUtil.Evaluate( "Timer-at observer", new MatchedEventMapImpl(convertor.MatchedEventMapMeta), parameters, convertor, null); _spec = ScheduleSpecUtil.ComputeValues(observerParameters.ToArray()); } catch (ScheduleParameterException e) { throw new ObserverParameterException( "Error computing crontab schedule specification: " + e.Message, e); } } }
protected internal static TimerScheduleSpec Compute( ExprEvaluator parameter, EventBean[] events, ExprEvaluatorContext exprEvaluatorContext) { object param = PatternExpressionUtil.EvaluateChecked( NAME_OBSERVER, parameter, events, exprEvaluatorContext); string iso = (string) param; if (iso == null) { throw new ScheduleParameterException("Received null parameter value"); } return TimerScheduleISO8601Parser.Parse(iso); }
public override EventObserver MakeObserver( PatternAgentInstanceContext context, MatchedEventMap beginState, ObserverEventEvaluator observerEventEvaluator, EvalStateNodeNumber stateNodeId, Object observerState, bool isFilterChildNonQuitting) { Object filename = PatternExpressionUtil.Evaluate( "File-exists observer ", beginState, FilenameExpression, Convertor, null); if (filename == null) { throw new EPException("Filename evaluated to null"); } return(new MyFileExistsObserver(beginState, observerEventEvaluator, filename.ToString())); }
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 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 void EvaluateTrue( MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted, EventBean optionalTriggeringEvent) { var agentInstanceContext = everyNode.Context.AgentInstanceContext; agentInstanceContext.InstrumentationProvider.QPatternEveryDistinctEvaluateTrue( everyNode.factoryNode, matchEvent); // determine if this evaluation has been seen before from the same node var matchEventKey = PatternExpressionUtil.GetKeys( matchEvent, everyNode.FactoryNode.Convertor, everyNode.FactoryNode.DistinctExpression, everyNode.Context.AgentInstanceContext); var haveSeenThis = false; IDictionary<object, long> keysFromNode = spawnedNodes.Get(fromNode); if (keysFromNode != null) { // Clean out old keys var keysToRemove = new List<object>(); var enumerator = keysFromNode.GetEnumerator(); var currentTime = everyNode.Context.AgentInstanceContext.TimeProvider.Time; for (; enumerator.MoveNext();) { var entry = enumerator.Current; if (currentTime >= entry.Value) { keysToRemove.Add(entry.Key); } else { break; } } // Remove the keys keysToRemove.ForEach(key => keysFromNode.Remove(key)); if (keysFromNode.ContainsKey(matchEventKey)) { haveSeenThis = true; } else { var expiryTime = everyNode.FactoryNode.AbsExpiry(everyNode.Context); keysFromNode.Put(matchEventKey, expiryTime); } } if (isQuitted) { spawnedNodes.Remove(fromNode); } // See explanation in EvalFilterStateNode for the type check if (fromNode.IsFilterStateNode) { // We do not need to newState new listeners here, since the filter state node below this node did not quit } else { // Spawn all nodes below this EVERY node // During the start of a child we need to use the temporary evaluator to catch any event created during a start // Such events can be raised when the "not" operator is used. var spawnEvaluator = new EvalEveryStateSpawnEvaluator(everyNode.Context.StatementName); var spawned = everyNode.ChildNode.NewState(spawnEvaluator); spawned.Start(beginState); // If the whole spawned expression already turned true, quit it again if (spawnEvaluator.IsEvaluatedTrue) { spawned.Quit(); } else { var keyset = new LinkedHashMap<object, long>(); if (keysFromNode != null) { keyset.PutAll(keysFromNode); } spawnedNodes.Put(spawned, keyset); spawned.ParentEvaluator = this; } } if (!haveSeenThis) { agentInstanceContext.AuditProvider.PatternTrue( everyNode.FactoryNode, this, matchEvent, false, agentInstanceContext); ParentEvaluator.EvaluateTrue(matchEvent, this, false, optionalTriggeringEvent); } agentInstanceContext.InstrumentationProvider.APatternEveryDistinctEvaluateTrue( null, keysFromNode, matchEventKey, haveSeenThis); }
protected internal static TimerScheduleSpec Compute( ExprEvaluator date, ExprEvaluator repetitions, TimePeriodEval timePeriod, EventBean[] eventsPerStream, ExprEvaluatorContext exprEvaluatorContext, TimeZoneInfo timeZone, TimeAbacus timeAbacus) { DateTimeEx optionalDate = null; long? optionalRemainder = null; if (date != null) { object param = PatternExpressionUtil.EvaluateChecked( TimerScheduleObserverForge.NAME_OBSERVER, date, eventsPerStream, exprEvaluatorContext); if (param is string) { optionalDate = TimerScheduleISO8601Parser.ParseDate((string) param); } else if (TypeHelper.IsNumber(param)) { long msec = param.AsInt64(); optionalDate = DateTimeEx.GetInstance(timeZone); optionalRemainder = timeAbacus.DateTimeSet(msec, optionalDate); } else if (param is DateTimeEx dateTimeEx) { optionalDate = DateTimeEx.GetInstance(timeZone, dateTimeEx); } else if (param is DateTime dateTime) { optionalDate = DateTimeEx.GetInstance(timeZone, dateTime); } else if (param is DateTimeOffset dateTimeOffset) { optionalDate = DateTimeEx.GetInstance(timeZone, dateTimeOffset); } else if (param == null) { throw new EPException("Null date-time value returned from date evaluation"); } else { throw new EPException("Unrecognized date-time value " + param.GetType()); } } TimePeriod optionalTimePeriod = null; if (timePeriod != null) { try { optionalTimePeriod = timePeriod.TimePeriodEval(eventsPerStream, true, exprEvaluatorContext); } catch (EPException) { throw; } catch (Exception ex) { PatternExpressionUtil.HandleRuntimeEx(ex, NAME_OBSERVER); } } long? optionalRepeatCount = null; if (repetitions != null) { object param = PatternExpressionUtil.EvaluateChecked( NAME_OBSERVER, repetitions, eventsPerStream, exprEvaluatorContext); if (param != null) { optionalRepeatCount = (param).AsInt64(); } } if (optionalDate == null && optionalTimePeriod == null) { throw new EPException("Required date or time period are both null for " + NAME_OBSERVER); } return new TimerScheduleSpec(optionalDate, optionalRemainder, optionalRepeatCount, optionalTimePeriod); }
public void EvaluateTrue( MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted, EventBean optionalTriggeringEvent) { var agentInstanceContext = everyDistinctNode.Context.AgentInstanceContext; agentInstanceContext.InstrumentationProvider.QPatternEveryDistinctEvaluateTrue( everyDistinctNode.factoryNode, matchEvent); // determine if this evaluation has been seen before from the same node var matchEventKey = PatternExpressionUtil.GetKeys( matchEvent, everyDistinctNode.FactoryNode.Convertor, everyDistinctNode.FactoryNode.DistinctExpression, everyDistinctNode.Context.AgentInstanceContext); var haveSeenThis = false; var keysFromNode = spawnedNodes.Get(fromNode); if (keysFromNode != null) { if (keysFromNode.Contains(matchEventKey)) { haveSeenThis = true; } else { keysFromNode.Add(matchEventKey); } } if (isQuitted) { spawnedNodes.Remove(fromNode); } // See explanation in EvalFilterStateNode for the type check if (fromNode.IsFilterStateNode) { // We do not need to newState new listeners here, since the filter state node below this node did not quit } else { // Spawn all nodes below this EVERY node // During the start of a child we need to use the temporary evaluator to catch any event created during a start // Such events can be raised when the "not" operator is used. var spawnEvaluator = new EvalEveryStateSpawnEvaluator(everyDistinctNode.Context.StatementName); var spawned = everyDistinctNode.ChildNode.NewState(spawnEvaluator); spawned.Start(beginState); // If the whole spawned expression already turned true, quit it again if (spawnEvaluator.IsEvaluatedTrue) { spawned.Quit(); } else { ISet<object> keyset = new HashSet<object>(); if (keysFromNode != null) { keyset.AddAll(keysFromNode); } spawnedNodes.Put(spawned, keyset); spawned.ParentEvaluator = this; } } if (!haveSeenThis) { agentInstanceContext.AuditProvider.PatternTrue( everyDistinctNode.FactoryNode, this, matchEvent, false, agentInstanceContext); ParentEvaluator.EvaluateTrue(matchEvent, this, false, optionalTriggeringEvent); } agentInstanceContext.InstrumentationProvider.APatternEveryDistinctEvaluateTrue( keysFromNode, null, matchEventKey, haveSeenThis); }
public override void ToPrecedenceFreeEPL(TextWriter writer) { PatternExpressionUtil.ToPrecedenceFreeEPL(writer, "and", ChildNodes, Precedence); }
public TimerScheduleSpec Compute( MatchedEventConvertor convertor, MatchedEventMap beginState, ExprEvaluatorContext exprEvaluatorContext, TimeZoneInfo timeZone, TimeAbacus timeAbacus) { DateTimeEx optionalDate = null; long? optionalRemainder = null; if (_dateNode != null) { Object param = PatternExpressionUtil.Evaluate( NAME_OBSERVER, beginState, _dateNode, convertor, exprEvaluatorContext); if (param is string) { optionalDate = TimerScheduleISO8601Parser.ParseDate((string) param); } else if (param.IsLong() || param.IsInt()) { long msec = param.AsLong(); optionalDate = DateTimeEx.GetInstance(timeZone); timeAbacus.CalendarSet(msec, optionalDate); //optionalDate = new DateTimeEx(msec.AsDateTimeOffset(timeZone), timeZone); optionalRemainder = timeAbacus.CalendarSet(msec, optionalDate); } else if (param is DateTimeOffset || param is DateTime) { optionalDate = new DateTimeEx(param.AsDateTimeOffset(timeZone), timeZone); } else if (param is DateTimeEx) { optionalDate = (DateTimeEx) param; } else if (param == null) { throw new EPException( "Null date-time value returned from " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(_dateNode)); } else { throw new EPException("Unrecognized date-time value " + param.GetType()); } } TimePeriod optionalTimePeriod = null; if (_periodNode != null) { object param = PatternExpressionUtil.EvaluateTimePeriod( NAME_OBSERVER, beginState, _periodNode, convertor, exprEvaluatorContext); optionalTimePeriod = (TimePeriod) param; } long? optionalRepeatCount = null; if (_repetitionsNode != null) { object param = PatternExpressionUtil.Evaluate( NAME_OBSERVER, beginState, _repetitionsNode, convertor, exprEvaluatorContext); if (param != null) { optionalRepeatCount = param.AsLong(); } } if (optionalDate == null && optionalTimePeriod == null) { throw new EPException("Required date or time period are both null for " + NAME_OBSERVER); } return new TimerScheduleSpec(optionalDate, optionalRemainder, optionalRepeatCount, optionalTimePeriod); }