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);
}
