public void SetGuardParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
StatementCompileTimeServices services)
{
var message = "Timer-within-or-max-count guard requires two parameters: " +
"numeric or time period parameter and an integer-value expression parameter";
if (parameters.Count != 2) {
throw new GuardParameterException(message);
}
if (!parameters[0].Forge.EvaluationType.IsNumeric()) {
throw new GuardParameterException(message);
}
var paramOneType = parameters[1].Forge.EvaluationType;
if (paramOneType != typeof(int) && paramOneType != typeof(int)) {
throw new GuardParameterException(message);
}
timeExpr = parameters[0];
numCountToExpr = parameters[1];
this.convertor = convertor;
timeAbacus = services.ImportServiceCompileTime.TimeAbacus;
}
public FilterForEvalLimitedExprForge(
ExprNode value,
MatchedEventConvertorForge convertor,
Coercer numberCoercer)
{
this.value = value;
this.convertor = convertor;
this.numberCoercer = numberCoercer;
}
public FilterSpecPlanForge(
FilterSpecPlanPathForge[] paths,
ExprNode filterConfirm,
ExprNode filterNegate,
MatchedEventConvertorForge convertorForge)
{
Paths = paths;
FilterConfirm = filterConfirm;
FilterNegate = filterNegate;
ConvertorForge = convertorForge;
}
public FilterSpecParamValueLimitedExprForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
ExprNode value,
MatchedEventConvertorForge convertor,
Coercer numberCoercer)
: base(lookupable, filterOperator)
{
this._value = value;
this._convertor = convertor;
this._numberCoercer = numberCoercer;
}
public static FilterSpecPlanForge MakePlanFromTriplets(
ICollection<FilterSpecPlanPathTripletForge> triplets,
ExprNode topLevelNegation,
FilterSpecCompilerArgs args)
{
var path = MakePathFromTriplets(triplets, null);
var convertor = new MatchedEventConvertorForge(
args.taggedEventTypes,
args.arrayEventTypes,
args.allTagNamesOrdered,
null,
true);
return new FilterSpecPlanForge(new[] {path}, null, topLevelNegation, convertor);
}
public void SetObserverParameters(
IList<ExprNode> observerParameters,
MatchedEventConvertorForge convertor,
ExprValidationContext validationContext)
{
var message = "File exists observer takes a single string filename parameter";
if (observerParameters.Count != 1) {
throw new ObserverParameterException(message);
}
if (!(observerParameters[0].Forge.EvaluationType == typeof(string))) {
throw new ObserverParameterException(message);
}
filenameExpression = observerParameters[0];
this.convertor = convertor;
}
public void SetGuardParameters(
IList<ExprNode> guardParameters,
MatchedEventConvertorForge convertor,
StatementCompileTimeServices services)
{
var message = "Count-to guard takes a single integer-value expression as parameter";
if (guardParameters.Count != 1) {
throw new GuardParameterException(message);
}
var paramType = guardParameters[0].Forge.EvaluationType;
if (paramType != typeof(int?) && paramType != typeof(int)) {
throw new GuardParameterException(message);
}
numCountToExpr = guardParameters[0];
this.convertor = convertor;
}
public void SetGuardParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
StatementCompileTimeServices services)
{
var errorMessage = "Timer-within guard requires a single numeric or time period parameter";
if (parameters.Count != 1) {
throw new GuardParameterException(errorMessage);
}
if (!parameters[0].Forge.EvaluationType.IsNumeric()) {
throw new GuardParameterException(errorMessage);
}
this.convertor = convertor;
timeExpr = parameters[0];
timeAbacus = services.ImportServiceCompileTime.TimeAbacus;
}
public void SetGuardParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
StatementCompileTimeServices services)
{
var errorMessage =
"Expression pattern guard requires a single expression as a parameter returning a true or false (boolean) value";
if (parameters.Count != 1) {
throw new GuardParameterException(errorMessage);
}
expression = parameters[0];
if (parameters[0].Forge.EvaluationType.GetBoxedType() != typeof(bool?)) {
throw new GuardParameterException(errorMessage);
}
this.convertor = convertor;
}
public void SetObserverParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
ExprValidationContext validationContext)
{
ObserverParameterUtil.ValidateNoNamedParameters(NAME, parameters);
var errorMessage = NAME + " requires a single numeric or time period parameter";
if (parameters.Count != 1) {
throw new ObserverParameterException(errorMessage);
}
if (!(parameters[0] is ExprTimePeriod)) {
var returnType = parameters[0].Forge.EvaluationType;
if (!returnType.IsNumeric()) {
throw new ObserverParameterException(errorMessage);
}
}
parameter = parameters[0];
this.convertor = convertor;
timeAbacus = validationContext.ImportService.TimeAbacus;
}
public void SetObserverParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
ExprValidationContext validationContext)
{
ObserverParameterUtil.ValidateNoNamedParameters("timer:at", parameters);
if (Log.IsDebugEnabled) {
Log.Debug(".setObserverParameters " + parameters);
}
if (parameters.Count < 5 || parameters.Count > 9) {
throw new ObserverParameterException("Invalid number of parameters for timer:at");
}
this.parameters = parameters;
this.convertor = convertor;
// if all parameters are constants, lets try to evaluate and build a schedule for early validation
var allConstantResult = true;
foreach (var param in parameters) {
if (!(param is ExprWildcard) && !param.Forge.ForgeConstantType.IsCompileTimeConstant) {
allConstantResult = false;
}
}
if (allConstantResult) {
try {
var observerParameters = EvaluateCompileTime(parameters);
spec = ScheduleSpecUtil.ComputeValues(observerParameters.ToArray());
}
catch (ScheduleParameterException e) {
throw new ObserverParameterException(
"Error computing crontab schedule specification: " + e.Message,
e);
}
}
}
private static FilterSpecParamFilterForEvalForge HandleRangeNodeEndpoint(
ExprNode endpoint,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
ISet<string> allTagNamesOrdered,
string statementName,
StatementRawInfo raw,
StatementCompileTimeServices services)
{
// constant
if (endpoint.Forge.ForgeConstantType.IsCompileTimeConstant) {
var value = endpoint.Forge.ExprEvaluator.Evaluate(null, true, null);
if (value == null) {
return null;
}
if (value is string) {
return new FilterForEvalConstantStringForge((string) value);
}
return new FilterForEvalConstantDoubleForge(value.AsDouble());
}
if (endpoint is ExprContextPropertyNode) {
var node = (ExprContextPropertyNode) endpoint;
if (node.Type == typeof(string)) {
return new FilterForEvalContextPropStringForge(node.Getter, node.PropertyName);
}
return new FilterForEvalContextPropDoubleForge(node.Getter, node.PropertyName);
}
if (endpoint.Forge.ForgeConstantType.IsDeployTimeTimeConstant && endpoint is ExprNodeDeployTimeConst) {
var node = (ExprNodeDeployTimeConst) endpoint;
if (endpoint.Forge.EvaluationType == typeof(string)) {
return new FilterForEvalDeployTimeConstStringForge(node);
}
return new FilterForEvalDeployTimeConstDoubleForge(node);
}
// or property
if (endpoint is ExprIdentNode) {
return GetIdentNodeDoubleEval((ExprIdentNode) endpoint, arrayEventTypes, statementName);
}
// or limited expression
if (FilterSpecCompilerIndexPlannerHelper.HasLevelOrHint(FilterSpecCompilerIndexPlannerHint.VALUECOMPOSITE, raw, services) &&
IsLimitedValueExpression(endpoint)) {
var returnType = endpoint.Forge.EvaluationType;
MatchedEventConvertorForge convertor = GetMatchEventConvertor(endpoint, taggedEventTypes, arrayEventTypes, allTagNamesOrdered);
if (returnType == typeof(string)) {
return new FilterForEvalLimitedExprForge(endpoint, convertor, null);
}
var coercer = SimpleNumberCoercerFactory.GetCoercer(returnType, typeof(double?));
return new FilterForEvalLimitedExprForge(endpoint, convertor, coercer);
}
return null;
}
private static void RecursiveCompile(
EvalForgeNode evalNode,
ISet<string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
Stack<EvalForgeNode> parentNodeStack,
ISet<string> allTagNamesOrdered,
int streamNum,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
parentNodeStack.Push(evalNode);
foreach (var child in evalNode.ChildNodes) {
RecursiveCompile(
child,
eventTypeReferences,
isInsertInto,
tags,
parentNodeStack,
allTagNamesOrdered,
streamNum,
statementRawInfo,
services);
}
parentNodeStack.Pop();
IDictionary<string, Pair<EventType, string>> newTaggedEventTypes = null;
IDictionary<string, Pair<EventType, string>> newArrayEventTypes = null;
if (evalNode is EvalFilterForgeNode) {
var filterNode = (EvalFilterForgeNode) evalNode;
var eventName = filterNode.RawFilterSpec.EventTypeName;
if (services.TableCompileTimeResolver.Resolve(eventName) != null) {
throw new ExprValidationException("Tables cannot be used in pattern filter atoms");
}
var resolvedEventType = ResolveTypeName(eventName, services.EventTypeCompileTimeResolver);
var finalEventType = resolvedEventType;
var optionalTag = filterNode.EventAsName;
var isPropertyEvaluation = false;
var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack);
// obtain property event type, if final event type is properties
if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) {
var optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator(
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
resolvedEventType,
filterNode.EventAsName,
statementRawInfo,
services);
finalEventType = optionalPropertyEvaluator.FragmentEventType;
isPropertyEvaluation = true;
}
// If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no
if (optionalTag != null) {
var pair = tags.TaggedEventTypes.Get(optionalTag);
EventType existingType = null;
if (pair != null) {
existingType = pair.First;
}
if (existingType == null) {
pair = tags.ArrayEventTypes.Get(optionalTag);
if (pair != null) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' used in the repeat-until operator cannot also appear in other filter expressions");
}
}
if (existingType != null && existingType != finalEventType) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' has already been declared for events of type " +
existingType.UnderlyingType.Name);
}
pair = new Pair<EventType, string>(finalEventType, eventName);
// add tagged type
if (isPropertyEvaluation || isParentMatchUntil) {
newArrayEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newArrayEventTypes.Put(optionalTag, pair);
}
else {
newTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newTaggedEventTypes.Put(optionalTag, pair);
}
}
// For this filter, filter types are all known tags at this time,
// and additionally stream 0 (self) is our event type.
// Stream type service allows resolution by property name event if that name appears in other tags.
// by defaulting to stream zero.
// Stream zero is always the current event type, all others follow the order of the map (stream 1 to N).
var selfStreamName = optionalTag;
if (selfStreamName == null) {
selfStreamName = "s_" + UuidGenerator.Generate();
}
var filterTypes = new LinkedHashMap<string, Pair<EventType, string>>();
var typePair = new Pair<EventType, string>(finalEventType, eventName);
filterTypes.Put(selfStreamName, typePair);
filterTypes.PutAll(tags.TaggedEventTypes);
// for the filter, specify all tags used
var filterTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(tags.TaggedEventTypes);
filterTaggedEventTypes.Remove(optionalTag);
// handle array tags (match-until clause)
IDictionary<string, Pair<EventType, string>> arrayCompositeEventTypes = null;
if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) {
arrayCompositeEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
foreach (var entry in tags.ArrayEventTypes) {
var specificArrayType = new LinkedHashMap<string, Pair<EventType, string>>();
specificArrayType.Put(entry.Key, entry.Value);
var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousPatternNameWTag(
streamNum,
evalNode.FactoryNodeId,
entry.Key);
var mapProps = GetMapProperties(
Collections.GetEmptyMap<string, Pair<EventType, string>>(),
specificArrayType);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.PATTERNDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var mapEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
mapProps,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(mapEventType);
var tag = entry.Key;
if (!filterTypes.ContainsKey(tag)) {
var pair = new Pair<EventType, string>(mapEventType, tag);
filterTypes.Put(tag, pair);
arrayCompositeEventTypes.Put(tag, pair);
}
}
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(filterTypes, true, false);
var exprNodes = filterNode.RawFilterSpec.FilterExpressions;
var spec = FilterSpecCompiler.MakeFilterSpec(
resolvedEventType,
eventName,
exprNodes,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
filterTaggedEventTypes,
arrayCompositeEventTypes,
streamTypeService,
null,
statementRawInfo,
services);
filterNode.FilterSpec = spec;
}
else if (evalNode is EvalObserverForgeNode) {
var observerNode = (EvalObserverForgeNode) evalNode;
try {
var observerForge =
services.PatternResolutionService.Create(observerNode.PatternObserverSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
observerNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNOBSERVER,
observerNode.PatternObserverSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
observerNode.ObserverFactory = observerForge;
observerForge.SetObserverParameters(validated, convertor, validationContext);
}
catch (ObserverParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern observer '" +
observerNode.ToPrecedenceFreeEPL() +
"': " +
e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalGuardForgeNode) {
var guardNode = (EvalGuardForgeNode) evalNode;
try {
var guardForge = services.PatternResolutionService.Create(guardNode.PatternGuardSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
guardNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNGUARD,
guardNode.PatternGuardSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
guardNode.GuardForge = guardForge;
guardForge.SetGuardParameters(validated, convertor, services);
}
catch (GuardParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalEveryDistinctForgeNode) {
var distinctNode = (EvalEveryDistinctForgeNode) evalNode;
var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode);
var streamTypeService = GetStreamTypeService(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
distinctNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
IList<ExprNode> validated;
try {
validated = ValidateExpressions(
ExprNodeOrigin.PATTERNEVERYDISTINCT,
distinctNode.Expressions,
validationContext);
}
catch (ExprValidationPropertyException ex) {
throw new ExprValidationPropertyException(
ex.Message +
", every-distinct requires that all properties resolve from sub-expressions to the every-distinct",
ex.InnerException);
}
var convertor = new MatchedEventConvertorForge(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
allTagNamesOrdered);
distinctNode.Convertor = convertor;
// Determine whether some expressions are constants or time period
IList<ExprNode> distinctExpressions = new List<ExprNode>();
TimePeriodComputeForge timePeriodComputeForge = null;
ExprNode expiryTimeExp = null;
var count = -1;
var last = validated.Count - 1;
foreach (var expr in validated) {
count++;
if (count == last && expr is ExprTimePeriod) {
expiryTimeExp = expr;
var timePeriodExpr = (ExprTimePeriod) expiryTimeExp;
timePeriodComputeForge = timePeriodExpr.TimePeriodComputeForge;
}
else if (expr.Forge.ForgeConstantType.IsCompileTimeConstant) {
if (count == last) {
var value = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
if (!value.IsNumber()) {
throw new ExprValidationException(
"Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)");
}
var secondsExpire = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
var timeExpire = secondsExpire == null
? (long?) null
: (long?) services.ImportServiceCompileTime.TimeAbacus.DeltaForSecondsNumber(
secondsExpire);
if (timeExpire != null && timeExpire > 0) {
timePeriodComputeForge = new TimePeriodComputeConstGivenDeltaForge(timeExpire.Value);
expiryTimeExp = expr;
}
else {
Log.Warn(
"Invalid seconds-expire " +
timeExpire +
" for " +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr));
}
}
else {
Log.Warn(
"Every-distinct node utilizes an expression returning a constant value, please check expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr) +
"', not adding expression to distinct-value expression list");
}
}
else {
distinctExpressions.Add(expr);
}
}
if (distinctExpressions.IsEmpty()) {
throw new ExprValidationException(
"Every-distinct node requires one or more distinct-value expressions that each return non-constant result values");
}
distinctNode.SetDistinctExpressions(distinctExpressions, timePeriodComputeForge, expiryTimeExp);
}
else if (evalNode is EvalMatchUntilForgeNode) {
var matchUntilNode = (EvalMatchUntilForgeNode) evalNode;
// compile bounds expressions, if any
var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes);
var streamTypeService = GetStreamTypeService(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
matchUntilNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext);
matchUntilNode.LowerBounds = lower;
var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext);
matchUntilNode.UpperBounds = upper;
var single = ValidateBounds(matchUntilNode.SingleBound, validationContext);
matchUntilNode.SingleBound = single;
bool tightlyBound;
if (matchUntilNode.SingleBound != null) {
ValidateMatchUntil(matchUntilNode.SingleBound, matchUntilNode.SingleBound, false);
tightlyBound = true;
}
else {
var allowZeroLowerBounds = matchUntilNode.LowerBounds != null && matchUntilNode.UpperBounds != null;
tightlyBound = ValidateMatchUntil(
matchUntilNode.LowerBounds,
matchUntilNode.UpperBounds,
allowZeroLowerBounds);
}
if (matchUntilNode.SingleBound == null && !tightlyBound && matchUntilNode.ChildNodes.Count < 2) {
throw new ExprValidationException("Variable bounds repeat operator requires an until-expression");
}
var convertor = new MatchedEventConvertorForge(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
allTagNamesOrdered);
matchUntilNode.Convertor = convertor;
// compile new tag lists
ISet<string> arrayTags = null;
var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]);
foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) {
var optionalTag = filterNode.EventAsName;
if (optionalTag != null) {
if (arrayTags == null) {
arrayTags = new HashSet<string>();
}
arrayTags.Add(optionalTag);
}
}
if (arrayTags != null) {
foreach (var arrayTag in arrayTags) {
if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) {
tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag));
tags.TaggedEventTypes.Remove(arrayTag);
}
}
}
matchUntilNode.TagsArrayedSet = GetIndexesForTags(allTagNamesOrdered, arrayTags);
}
else if (evalNode is EvalFollowedByForgeNode) {
var followedByNode = (EvalFollowedByForgeNode) evalNode;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(false);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
if (followedByNode.OptionalMaxExpressions != null) {
IList<ExprNode> validated = new List<ExprNode>();
foreach (var maxExpr in followedByNode.OptionalMaxExpressions) {
if (maxExpr == null) {
validated.Add(null);
}
else {
var visitor = new ExprNodeSummaryVisitor();
maxExpr.Accept(visitor);
if (!visitor.IsPlain) {
var errorMessage = "Invalid maximum expression in followed-by, " +
visitor.Message +
" are not allowed within the expression";
Log.Error(errorMessage);
throw new ExprValidationException(errorMessage);
}
var validatedExpr = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FOLLOWEDBYMAX,
maxExpr,
validationContext);
validated.Add(validatedExpr);
var returnType = validatedExpr.Forge.EvaluationType;
if (returnType == null || !returnType.IsNumeric()) {
var message =
"Invalid maximum expression in followed-by, the expression must return an integer value";
throw new ExprValidationException(message);
}
}
}
followedByNode.OptionalMaxExpressions = validated;
}
}
if (newTaggedEventTypes != null) {
tags.TaggedEventTypes.PutAll(newTaggedEventTypes);
}
if (newArrayEventTypes != null) {
tags.ArrayEventTypes.PutAll(newArrayEventTypes);
}
}
public void SetObserverParameters(
IList<ExprNode> parameters,
MatchedEventConvertorForge convertor,
ExprValidationContext validationContext)
{
this.convertor = convertor;
// obtains name parameters
IDictionary<string, ExprNamedParameterNode> namedExpressions;
try {
namedExpressions = ExprNodeUtilityValidate.GetNamedExpressionsHandleDups(parameters);
ExprNodeUtilityValidate.ValidateNamed(namedExpressions, NAMED_PARAMETERS);
}
catch (ExprValidationException e) {
throw new ObserverParameterException(e.Message, e);
}
var isoStringExpr = namedExpressions.Get(ISO_NAME);
if (namedExpressions.Count == 1 && isoStringExpr != null) {
try {
allConstantResult = ExprNodeUtilityValidate.ValidateNamedExpectType(
isoStringExpr,
new[] {typeof(string)});
}
catch (ExprValidationException ex) {
throw new ObserverParameterException(ex.Message, ex);
}
scheduleComputer = new TimerScheduleSpecComputeISOStringForge(isoStringExpr.ChildNodes[0]);
}
else if (isoStringExpr != null) {
throw new ObserverParameterException(
"The '" + ISO_NAME + "' parameter is exclusive of other parameters");
}
else if (namedExpressions.Count == 0) {
throw new ObserverParameterException("No parameters provided");
}
else {
allConstantResult = true;
var dateNamedNode = namedExpressions.Get(DATE_NAME);
var repetitionsNamedNode = namedExpressions.Get(REPETITIONS_NAME);
var periodNamedNode = namedExpressions.Get(PERIOD_NAME);
if (dateNamedNode == null && periodNamedNode == null) {
throw new ObserverParameterException("Either the date or period parameter is required");
}
try {
if (dateNamedNode != null) {
allConstantResult = ExprNodeUtilityValidate.ValidateNamedExpectType(
dateNamedNode,
new[] {
typeof(string),
typeof(DateTimeEx),
typeof(DateTimeOffset),
typeof(DateTime),
typeof(long)
});
}
if (repetitionsNamedNode != null) {
allConstantResult &= ExprNodeUtilityValidate.ValidateNamedExpectType(
repetitionsNamedNode,
new[] {typeof(int), typeof(long)});
}
if (periodNamedNode != null) {
allConstantResult &= ExprNodeUtilityValidate.ValidateNamedExpectType(
periodNamedNode,
new[] {typeof(TimePeriod)});
}
}
catch (ExprValidationException ex) {
throw new ObserverParameterException(ex.Message, ex);
}
var dateNode = dateNamedNode == null ? null : dateNamedNode.ChildNodes[0];
var repetitionsNode = repetitionsNamedNode == null ? null : repetitionsNamedNode.ChildNodes[0];
var periodNode = periodNamedNode == null ? null : (ExprTimePeriod) periodNamedNode.ChildNodes[0];
scheduleComputer = new TimerScheduleSpecComputeFromExprForge(dateNode, repetitionsNode, periodNode);
}
if (allConstantResult) {
try {
scheduleComputer.VerifyComputeAllConst(validationContext);
}
catch (ScheduleParameterException ex) {
throw new ObserverParameterException(ex.Message, ex);
}
}
}
internal static FilterSpecPlanForge PlanRemainingNodesWithConditions(
FilterSpecParaForgeMap overallExpressions,
FilterSpecCompilerArgs args,
int filterServiceMaxFilterWidth,
ExprNode topLevelNegator)
{
var unassigned = overallExpressions.UnassignedExpressions;
var orNodes = new List <ExprOrNode>(unassigned.Count);
foreach (var node in unassigned)
{
if (node is ExprOrNode)
{
orNodes.Add((ExprOrNode)node);
}
}
var expressionsWithoutOr = new FilterSpecParaForgeMap();
expressionsWithoutOr.Add(overallExpressions);
// first dimension: or-node index
// second dimension: or child node index
var countOr = 0;
var sizeFactorized = 1;
var sizePerOr = new int[orNodes.Count];
var orChildNodes = new OrChildNode[orNodes.Count][];
var hasControl = false;
foreach (var orNode in orNodes)
{
expressionsWithoutOr.RemoveNode(orNode);
// get value-nodes and non-value nodes
var nonValueNodes = GetNonValueChildNodes(orNode);
var valueNodes = new List <ExprNode>(Arrays.AsList(orNode.ChildNodes));
valueNodes.RemoveAll(nonValueNodes);
ExprNode singleValueNode = ExprNodeUtilityMake.ConnectExpressionsByLogicalOrWhenNeeded(valueNodes);
// get all child nodes; last one is confirm if present
IList <ExprNode> allChildNodes = new List <ExprNode>(nonValueNodes);
if (singleValueNode != null)
{
allChildNodes.Add(singleValueNode);
}
var len = allChildNodes.Count;
orChildNodes[countOr] = new OrChildNode[len];
for (var i = 0; i < len; i++)
{
var child = allChildNodes[i];
if (child == singleValueNode)
{
hasControl = true;
orChildNodes[countOr][i] = new OrChildNodeV(singleValueNode);
}
else
{
var map = new FilterSpecParaForgeMap();
var nodes = Collections.SingletonList(child);
var confirm = DecomposePopulateConsolidate(map, true, nodes, args);
if (confirm == null)
{
orChildNodes[countOr][i] = new OrChildNodeNV(child, map);
}
else
{
hasControl = true;
orChildNodes[countOr][i] = new OrChildNodeNVNegated(child, map, confirm);
}
}
}
sizePerOr[countOr] = len;
sizeFactorized = sizeFactorized * len;
countOr++;
}
// compute permutations
var permutations = new CombPermutationTriplets[sizeFactorized];
var combinationEnumeration = CombinationEnumeration.FromZeroBasedRanges(sizePerOr);
var count = 0;
foreach (var permutation in combinationEnumeration)
{
permutations[count] = ComputePermutation(expressionsWithoutOr, permutation, orChildNodes, hasControl, args);
count++;
}
// Remove any permutations that only have a control-confirm
var result = new List <FilterSpecPlanPathForge>(sizeFactorized);
var pathControlConfirm = new List <ExprNode>();
foreach (var permutation in permutations)
{
if (permutation.Triplets.Length > 0)
{
result.Add(new FilterSpecPlanPathForge(permutation.Triplets, permutation.NegateCondition));
}
else
{
pathControlConfirm.Add(permutation.NegateCondition);
}
}
if (result.Count > filterServiceMaxFilterWidth)
{
return(null);
}
var pathArray = result.ToArray();
ExprNode topLevelConfirmer = ExprNodeUtilityMake.ConnectExpressionsByLogicalOrWhenNeeded(pathControlConfirm);
// determine when the path-negate condition is the same as the root confirm-expression
if (topLevelConfirmer != null)
{
var not = new ExprNotNode();
not.AddChildNode(topLevelConfirmer);
foreach (var path in pathArray)
{
if (ExprNodeUtilityCompare.DeepEquals(not, path.PathNegate, true))
{
path.PathNegate = null;
}
}
}
var convertor = new MatchedEventConvertorForge(
args.taggedEventTypes,
args.arrayEventTypes,
args.allTagNamesOrdered,
null,
true);
return(new FilterSpecPlanForge(pathArray, topLevelConfirmer, topLevelNegator, convertor));
}