public CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
ExprForge child = ChildNodes[0].Forge;
if (child.EvaluationType == typeof(bool)) {
Not(child.EvaluateCodegen(requiredType, codegenMethodScope, exprSymbol, codegenClassScope));
}
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(bool?),
typeof(ExprNotNode),
codegenClassScope);
methodNode.Block
.DeclareVar<bool?>("b", child.EvaluateCodegen(typeof(bool?), methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("b")
.MethodReturn(Not(Ref("b")));
return LocalMethod(methodNode);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ModuleDependenciesRuntime), GetType(), classScope);
method.Block
.DeclareVar<ModuleDependenciesRuntime>("md", NewInstance(typeof(ModuleDependenciesRuntime)))
.SetProperty(Ref("md"), "PathEventTypes", NameAndModule.MakeArray(pathEventTypes))
.SetProperty(Ref("md"), "PathNamedWindows", NameAndModule.MakeArray(pathNamedWindows))
.SetProperty(Ref("md"), "PathTables", NameAndModule.MakeArray(pathTables))
.SetProperty(Ref("md"), "PathVariables", NameAndModule.MakeArray(pathVariables))
.SetProperty(Ref("md"), "PathContexts", NameAndModule.MakeArray(pathContexts))
.SetProperty(Ref("md"), "PathExpressions", NameAndModule.MakeArray(pathExpressions))
.SetProperty(Ref("md"), "PathIndexes", ModuleIndexMeta.MakeArray(pathIndexes))
.SetProperty(Ref("md"), "PathScripts", NameParamNumAndModule.MakeArray(pathScripts))
.SetProperty(Ref("md"), "PathClasses", NameAndModule.MakeArray(pathClasses))
.SetProperty(Ref("md"), "PublicEventTypes", Constant(publicEventTypes.ToArray()))
.SetProperty(Ref("md"), "PublicVariables", Constant(publicVariables.ToArray()))
.MethodReturn(Ref("md"));
return LocalMethod(method);
}
private static CodegenExpression MakeOpMeta(
IDictionary<int, OperatorMetadataDescriptor> operatorMetadata,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(IDictionary<int, OperatorMetadataDescriptor>), typeof(DataflowDescForge), classScope);
method.Block.DeclareVar<IDictionary<int, OperatorMetadataDescriptor>>(
"op",
NewInstance(typeof(Dictionary<int, OperatorMetadataDescriptor>)));
foreach (var entry in operatorMetadata) {
method.Block.ExprDotMethod(
Ref("op"),
"Put",
Constant(entry.Key),
entry.Value.Make(method, symbols, classScope));
}
method.Block.MethodReturn(Ref("op"));
return LocalMethod(method);
}
private static CodegenExpression MakeTypes(
IDictionary<string, EventType> declaredTypes,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(IDictionary<string, EventType>), typeof(DataflowDescForge), classScope);
method.Block.DeclareVar<IDictionary<string, EventType>>(
"types",
NewInstance(typeof(Dictionary<string, EventType>)));
foreach (var entry in declaredTypes) {
method.Block.ExprDotMethod(
Ref("types"),
"Put",
Constant(entry.Key),
EventTypeUtility.ResolveTypeCodegen(entry.Value, symbols.GetAddInitSvc(method)));
}
method.Block.MethodReturn(Ref("types"));
return LocalMethod(method);
}
public CodegenExpression Codegen(
CodegenExpression reference,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(long),
typeof(IntervalDeltaExprTimePeriodNonConstForge),
codegenClassScope)
.AddParam(typeof(long), "reference");
methodNode.Block
.DeclareVar<double>(
"sec",
timePeriod.EvaluateAsSecondsCodegen(methodNode, exprSymbol, codegenClassScope))
.MethodReturn(
timeAbacus.DeltaForSecondsDoubleCodegen(
Ref("sec"), codegenClassScope));
return LocalMethod(methodNode, reference);
}
private CodegenMethod HandleNestedValueCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var block = codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(typeof(object), "value")
.Block
.IfRefNotTypeReturnConst(
"value",
typeof(IDictionary<string, object>),
null);
if (_nestedGetter is MapEventPropertyGetter eventPropertyGetter) {
return block.MethodReturn(
eventPropertyGetter.UnderlyingGetCodegen(
Cast(typeof(IDictionary<string, object>), Ref("value")),
codegenMethodScope,
codegenClassScope));
}
return block.MethodReturn(ConstantNull());
}
public CodegenExpression EvaluateGetEventBeanCodegen(
CodegenMethodScope parent,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (PreviousType == ExprPreviousNodePreviousType.PREVWINDOW ||
PreviousType == ExprPreviousNodePreviousType.PREVCOUNT) {
return ConstantNull();
}
var method = parent.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
method.Block
.IfCondition(Not(exprSymbol.GetAddIsNewData(method)))
.BlockReturn(ConstantNull())
.MethodReturn(
LocalMethod(
GetSubstituteCodegen(method, exprSymbol, codegenClassScope),
exprSymbol.GetAddEPS(method),
exprSymbol.GetAddExprEvalCtx(method)));
return LocalMethod(method);
}
public CodegenExpression EvaluateMatchesCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool), GetType(), classScope);
CodegenExpression aggService = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
new CodegenFieldNameSubqueryAgg(subselect.SubselectNumber),
typeof(AggregationResultFuture));
method.Block.ApplyTri(
new SubselectForgeCodegenUtil.ReturnIfNoMatch(ConstantFalse(), ConstantFalse()),
method,
symbols);
method.Block.MethodReturn(
Not(
ExprDotMethodChain(aggService)
.Add("GetGroupKeys", symbols.GetAddExprEvalCtx(method))
.Add("IsEmpty")));
return LocalMethod(method);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(
typeof(StatementAgentInstanceFactoryCreateExpression),
this.GetType(),
classScope);
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateExpression>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactoryCreateExpression)))
.SetProperty(
Ref("saiff"),
"StatementEventType",
EventTypeUtility.ResolveTypeCodegen(statementEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("saiff"), "ExpressionName", Constant(expressionName))
.MethodReturn(Ref("saiff"));
return method;
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(SubSelectFactory), GetType(), classScope);
method.Block
.DeclareVar<SubSelectFactory>("factory", NewInstance(typeof(SubSelectFactory)))
.SetProperty(Ref("factory"), "SubqueryNumber", Constant(subqueryNumber))
.SetProperty(Ref("factory"), "Activator", activator.MakeCodegen(method, symbols, classScope))
.SetProperty(
Ref("factory"),
"StrategyFactory",
strategyFactoryForge.MakeCodegen(method, symbols, classScope))
.SetProperty(Ref("factory"), "HasAggregation", Constant(strategyFactoryForge.HasAggregation))
.SetProperty(Ref("factory"), "HasPrior", Constant(strategyFactoryForge.HasPrior))
.SetProperty(Ref("factory"), "HasPrevious", Constant(strategyFactoryForge.HasPrevious))
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("factory"))
.MethodReturn(Ref("factory"));
return LocalMethod(method);
}
public CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
_returnType,
typeof(ExprEvalStreamInsertUnd),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.IfCondition(EqualsNull(refEPS))
.BlockReturn(ConstantNull())
.DeclareVar<EventBean>("bean", ArrayAtIndex(refEPS, Constant(_streamNum)))
.IfRefNullReturnNull("bean")
.MethodReturn(FlexCast(_returnType, ExprDotUnderlying(Ref("bean"))));
return LocalMethod(methodNode);
}
private CodegenExpression MakeSubstitutionParamNames(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var named = _namespaceScope.SubstitutionParamsByName;
if (named.IsEmpty()) {
return ConstantNull();
}
var method = parent.MakeChild(typeof(IDictionary<string, int>), GetType(), classScope);
method.Block.DeclareVar<IDictionary<string, int>>(
"names",
NewInstance(typeof(Dictionary<string, int>)));
var count = 1;
foreach (var entry in named) {
method.Block.ExprDotMethod(Ref("names"), "Put", Constant(entry.Key), Constant(count++));
}
method.Block.MethodReturn(Ref("names"));
return LocalMethod(method);
}
public CodegenExpression EventBeanGetIndexedCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope,
CodegenExpression beanExpression,
CodegenExpression key)
{
var method = codegenMethodScope.MakeChild(typeof(object), typeof(WrapperGetterIndexed), codegenClassScope)
.AddParam(typeof(EventBean), "@event")
.AddParam(typeof(int), "index")
.Block
.DeclareVar<DecoratingEventBean>("wrapper", Cast(typeof(DecoratingEventBean), Ref("@event")))
.DeclareVar<EventBean>("wrapped", ExprDotName(Ref("wrapper"), "UnderlyingEvent"))
.IfRefNullReturnNull("wrapped")
.MethodReturn(
undIndexed.EventBeanGetIndexedCodegen(
codegenMethodScope,
codegenClassScope,
Ref("wrapped"),
Ref("index")));
return LocalMethodBuild(method).Pass(beanExpression).Pass(key).Call();
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
EvaluationType,
typeof(PropertyDotNonLambdaForge),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(streamId)))
.IfRefNullReturnNull("@event")
.MethodReturn(
CodegenLegoCast.CastSafeFromObjectType(
EvaluationType,
getter.EventBeanGetCodegen(Ref("@event"), methodNode, codegenClassScope)));
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean[]),
typeof(ExprEvalEnumerationSingleToCollForge),
codegenClassScope);
methodNode.Block
.DeclareVar<EventBean>(
"@event",
enumerationForge.EvaluateGetEventBeanCodegen(methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("@event")
.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(1)))
.AssignArrayElement(Ref("events"), Constant(0), Ref("@event"))
.MethodReturn(Ref("events"));
return LocalMethod(methodNode);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var type = EPTypeHelper.GetCodegenReturnType(_resultType);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var method = codegenMethodScope
.MakeChild(type, typeof(EnumFirstOfNoPredicateForge), codegenClassScope)
.AddParam(paramTypes)
.Block
.IfCondition(
Or(
EqualsNull(EnumForgeCodegenNames.REF_ENUMCOLL),
ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")))
.BlockReturn(ConstantNull())
.MethodReturn(
Cast(type, ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First")));
return LocalMethod(method, args.Expressions);
}
private CodegenMethod IsExistsPropertyCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(typeof(bool), GetType(), codegenClassScope)
.AddParam(typeof(object[]), "array")
.Block
.DeclareVar<object>("value", ArrayAtIndex(Ref("array"), Constant(propertyIndex)))
.IfRefNullReturnFalse("value")
.IfInstanceOf("value", typeof(EventBean))
.BlockReturn(
entryGetter.EventBeanExistsCodegen(
CastRef(typeof(EventBean), "value"),
codegenMethodScope,
codegenClassScope))
.MethodReturn(
entryGetter.UnderlyingExistsCodegen(
FlexCast(entryGetter.TargetType, Ref("value")),
codegenMethodScope,
codegenClassScope));
}
private CodegenMethod GetBeanPropInternalCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(BeanPropType, GetType(), codegenClassScope)
.AddParam(TargetType, "@object")
.AddParam(typeof(int), "index")
.Block
.DeclareVar<object>("value", ExprDotName(Ref("@object"), _field.Name))
.DeclareVar<IList<object>>(
"l",
CodegenLegoCast.CastSafeFromObjectType(
typeof(IList<object>),
Ref("value")))
.IfRefNullReturnNull("l")
.IfConditionReturnConst(Relational(ExprDotName(Ref("l"), "Count"), LE, Ref("index")), null)
.MethodReturn(
Cast(
BeanPropType,
ArrayAtIndex(Ref("l"), Ref("index"))));
}
public override CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(QueryGraphValueEntryRangeIn), GetType(), classScope);
method.Block
.DeclareVar<ExprEvaluator>(
"start",
ExprNodeUtilityCodegen.CodegenEvaluator(ExprStart.Forge, method, GetType(), classScope))
.DeclareVar<ExprEvaluator>(
"end",
ExprNodeUtilityCodegen.CodegenEvaluator(ExprEnd.Forge, method, GetType(), classScope))
.MethodReturn(
NewInstance<QueryGraphValueEntryRangeIn>(
EnumValue(typeof(QueryGraphRangeEnum), type.GetName()),
Ref("start"),
Ref("end"),
Constant(IsAllowRangeReversal)));
return LocalMethod(method);
}
private CodegenMethod MakeInstructions(
IList<BaseAssemblyNodeFactory> factories,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(BaseAssemblyNodeFactory[]), GetType(), classScope);
var parents = new int[factories.Count];
var children = new int[factories.Count][];
for (var i = 0; i < factories.Count; i++) {
var factory = factories[i];
parents[i] = factory.ParentNode == null ? -1 : FindFactoryChecked(factory.ParentNode, factories);
children[i] = new int[factory.ChildNodes.Count];
for (var child = 0; child < factory.ChildNodes.Count; child++) {
children[i][child] = FindFactoryChecked(factory.ChildNodes[child], factories);
}
}
method.Block
.DeclareVar<BaseAssemblyNodeFactory[]>(
"factories",
CodegenMakeableUtil.MakeArray(
"assemblyInstructions",
typeof(BaseAssemblyNodeFactory),
factories.ToArray(),
GetType(),
parent,
symbols,
classScope))
.StaticMethod(
typeof(LookupInstructionQueryPlanNodeForge),
"AssembleFactoriesIntoTree",
Ref("factories"),
Constant(parents),
Constant(children))
.MethodReturn(Ref("factories"));
return method;
}
public static CodegenExpression CodegenCalendar(
CalendarSetForge forge,
CodegenExpression dateTimeEx,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var field = Constant(forge.field);
var evaluationType = forge.valueExpr.EvaluationType;
if (evaluationType.CanNotBeNull()) {
var valueExpr = forge.valueExpr
.EvaluateCodegen(evaluationType, codegenMethodScope, exprSymbol, codegenClassScope);
return ExprDotMethod(dateTimeEx, "SetFieldValue", field, valueExpr);
}
else {
var methodNode = codegenMethodScope
.MakeChild(typeof(void), typeof(CalendarSetForgeOp), codegenClassScope)
.AddParam(typeof(DateTimeEx), "dtx");
var valueExpr = forge.valueExpr
.EvaluateCodegen(evaluationType, methodNode, exprSymbol, codegenClassScope);
methodNode.Block
.DeclareVar<int?>(
"value",
SimpleNumberCoercerFactory.CoercerInt.CoerceCodegenMayNull(
valueExpr,
forge.valueExpr.EvaluationType,
methodNode,
codegenClassScope))
.IfRefNullReturnNull("value")
.Expression(
ExprDotMethod(
dateTimeEx,
"SetFieldValue",
field,
Unbox<int?>(Ref("value"))))
.MethodEnd();
return LocalMethod(methodNode, dateTimeEx);
}
}
public CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope parent,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var method = parent.MakeChild(EvaluationType, GetType(), codegenClassScope);
var innerEval = CodegenLegoMethodExpression.CodegenExpression(InnerForge, method, codegenClassScope, true);
var eps = exprSymbol.GetAddEPS(method);
// see ExprPriorEvalStrategyBase
CodegenExpression future = codegenClassScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
priorStrategyFieldName,
typeof(PriorEvalStrategy));
var innerMethod = LocalMethod(
innerEval,
eps,
exprSymbol.GetAddIsNewData(method),
exprSymbol.GetAddExprEvalCtx(method));
method.Block
.DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber)))
.DeclareVar<EventBean>(
"substituteEvent",
ExprDotMethod(
future,
"GetSubstituteEvent",
Ref("originalEvent"),
exprSymbol.GetAddIsNewData(method),
Constant(ConstantIndexNumber),
Constant(RelativeIndex),
exprSymbol.GetAddExprEvalCtx(method),
Constant(StreamNumber)))
.AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent"))
.DeclareVar(EvaluationType, "evalResult", innerMethod)
.AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent"))
.MethodReturn(Ref("evalResult"));
return LocalMethod(method);
}
public static CodegenExpression CodegenStartEnd(
DTLocalDtxOpsIntervalForge forge,
CodegenExpression start,
CodegenExpression end,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpression timeZoneField =
codegenClassScope.AddOrGetDefaultFieldSharable(RuntimeSettingsTimeZoneField.INSTANCE);
var methodNode = codegenMethodScope
.MakeChild(typeof(bool?), typeof(DTLocalDtxOpsIntervalEval), codegenClassScope)
.AddParam(typeof(DateTimeEx), "startTimestamp")
.AddParam(typeof(DateTimeEx), "endTimestamp");
var block = methodNode.Block
.DeclareVar<long>("startLong", ExprDotName(Ref("startTimestamp"), "UtcMillis"))
.DeclareVar<long>("endLong", ExprDotName(Ref("endTimestamp"), "UtcMillis"))
.DeclareVar<DateTimeEx>("dtx", StaticMethod(typeof(DateTimeEx), "GetInstance", timeZoneField))
.Expression(ExprDotMethod(Ref("dtx"), "SetUtcMillis", Ref("startLong")));
EvaluateCalOpsDtxCodegen(
block,
forge.calendarForges,
Ref("dtx"),
methodNode,
exprSymbol,
codegenClassScope);
block.DeclareVar<long>("startTime", ExprDotName(Ref("dtx"), "UtcMillis"))
.DeclareVar<long>(
"endTime",
Op(Ref("startTime"), "+", Op(Ref("endLong"), "-", Ref("startLong"))))
.MethodReturn(
forge.intervalForge.Codegen(
Ref("startTime"),
Ref("endTime"),
methodNode,
exprSymbol,
codegenClassScope));
return LocalMethod(methodNode, start, end);
}
public override CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(VariableTriggerWriteDesc), GetType(), classScope);
method.Block
.DeclareVar<VariableTriggerWriteDesc>("desc", NewInstance(typeof(VariableTriggerWriteDesc)))
.SetProperty(
Ref("desc"),
"Type",
EventTypeUtility.ResolveTypeCodegen(Type, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("desc"),
"VariableName",
Constant(VariableName))
.SetProperty(
Ref("desc"),
"Writer",
EventTypeUtility.CodegenWriter(
Type,
evaluationType,
getterType,
Writer,
method,
GetType(),
classScope))
.SetProperty(
Ref("desc"),
"Getter",
EventTypeUtility.CodegenGetterWCoerce(
getter,
getterType,
null,
method,
GetType(),
classScope))
.MethodReturn(Ref("desc"));
return LocalMethod(method);
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(SubSelectStrategyFactoryLocalViewPreloaded), GetType(), classScope);
CodegenExpression groupKeyEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_groupKeys, null, _groupByMultiKeyClasses, method, classScope);
method.Block
.DeclareVar <SubSelectStrategyFactoryLocalViewPreloaded>("factory", NewInstance(typeof(SubSelectStrategyFactoryLocalViewPreloaded)))
.SetProperty(Ref("factory"), "SubqueryNumber", Constant(_subqueryNumber))
.SetProperty(Ref("factory"), "ViewFactories", ViewFactoryForgeUtil.CodegenForgesWInit(_viewForges, 0, _subqueryNumber, method, symbols, classScope))
.SetProperty(Ref("factory"), "ViewResourceDelegate", _viewResourceDelegateDesc.ToExpression())
.SetProperty(Ref("factory"), "EventTableFactoryFactory", _lookupStrategy.First.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "LookupStrategyFactory", _lookupStrategy.Second.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "AggregationServiceFactory", MakeAggregationService(_subqueryNumber, _aggregationServiceForgeDesc, classScope, method, symbols))
.SetProperty(Ref("factory"), "CorrelatedSubquery", Constant(_correlatedSubquery))
.SetProperty(Ref("factory"), "GroupKeyEval", groupKeyEval)
.SetProperty(Ref("factory"), "FilterExprEval", _filterExprNode == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(_filterExprNode.Forge, method, GetType(), classScope));
if (_namedWindow != null)
{
method.Block.SetProperty(
Ref("factory"), "NamedWindow", NamedWindowDeployTimeResolver.MakeResolveNamedWindow(_namedWindow, symbols.GetAddInitSvc(method)));
if (_namedWindowFilterExpr != null)
{
method.Block
.SetProperty(Ref("factory"), "NamedWindowFilterQueryGraph",
_namedWindowFilterQueryGraph.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "NamedWindowFilterExpr",
ExprNodeUtilityCodegen.CodegenEvaluator(_namedWindowFilterExpr.Forge, method, GetType(), classScope));
}
}
method.Block.MethodReturn(Ref("factory"));
return(LocalMethod(method));
}
public CodegenMethod MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(FilterSpecActivatable), typeof(FilterSpecCompiled), classScope);
if (filterCallbackId == -1) {
throw new IllegalStateException("Unassigned filter callback id");
}
var propertyEval = OptionalPropertyEvaluator == null
? ConstantNull()
: OptionalPropertyEvaluator.Make(method, symbols, classScope);
method.Block
.DeclareVar<EventType>(
"eventType",
EventTypeUtility.ResolveTypeCodegen(FilterForEventType, EPStatementInitServicesConstants.REF))
.DeclareVar<FilterSpecParam[][]>(
"parameters",
LocalMethod(
FilterSpecParamForge.MakeParamArrayArrayCodegen(Parameters, classScope, method),
Ref("eventType"),
symbols.GetAddInitSvc(method)))
.DeclareVar<FilterSpecActivatable>(
"activatable",
NewInstance<FilterSpecActivatable>(
SAIFFInitializeSymbolWEventType.REF_EVENTTYPE,
Constant(FilterForEventType.Name),
Ref("parameters"),
propertyEval,
Constant(filterCallbackId)))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.FILTERSPECACTIVATABLEREGISTRY)
.Add("Register", Ref("activatable")))
.MethodReturn(Ref("activatable"));
return method;
}
public CodegenExpression CodegenNoNullCheck(
CodegenExpression value,
Type valueType,
CodegenExpression lower,
Type lowerType,
CodegenExpression higher,
Type higherType,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var block = codegenMethodScope.MakeChild(typeof(bool), typeof(ExprBetweenCompDouble), codegenClassScope)
.AddParam(typeof(decimal), "value")
.AddParam(typeof(decimal), "lower")
.AddParam(typeof(decimal), "upper")
.Block
.IfCondition(Relational(Ref("lower"), GT, Ref("upper")))
.DeclareVar<decimal>("temp", Ref("upper"))
.AssignRef("upper", Ref("lower"))
.AssignRef("lower", Ref("temp"))
.BlockEnd();
var ifValueGtLower = block.IfCondition(Relational(Ref("value"), GT, Ref("lower")));
{
ifValueGtLower.IfCondition(Relational(Ref("value"), LT, Ref("upper"))).BlockReturn(ConstantTrue());
if (_isHighIncluded) {
ifValueGtLower.BlockReturn(EqualsIdentity(Ref("value"), Ref("upper")));
}
else {
ifValueGtLower.BlockReturn(ConstantFalse());
}
}
CodegenMethod method;
if (_isLowIncluded) {
method = block.MethodReturn(EqualsIdentity(Ref("value"), Ref("lower")));
}
else {
method = block.MethodReturn(ConstantFalse());
}
return LocalMethod(method, value, lower, higher);
}
public static CodegenExpression CodegenEvaluate(
InnerDotArrObjectToCollForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(ICollection<object>),
typeof(InnerDotArrObjectToCollEval),
codegenClassScope);
Type evalType = forge.rootForge.EvaluationType;
methodNode.Block
.DeclareVar(
forge.rootForge.EvaluationType,
"array",
forge.rootForge.EvaluateCodegen(evalType, methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("array")
.MethodReturn(
Unwrap<object>(Ref("array")));
return LocalMethod(methodNode);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var methodNode = parent.MakeChild(typeof(SubordTableLookupStrategyFactoryQuadTree), GetType(), classScope);
Func<ExprForge, CodegenExpression> toExpr = forge =>
ExprNodeUtilityCodegen.CodegenEvaluator(forge, methodNode, GetType(), classScope);
methodNode.Block
.DeclareVar<SubordTableLookupStrategyFactoryQuadTree>(
"sts",
NewInstance(typeof(SubordTableLookupStrategyFactoryQuadTree)))
.SetProperty(Ref("sts"), "X", toExpr.Invoke(x))
.SetProperty(Ref("sts"), "Y", toExpr.Invoke(y))
.SetProperty(Ref("sts"), "Width", toExpr.Invoke(width))
.SetProperty(Ref("sts"), "Height", toExpr.Invoke(height))
.SetProperty(Ref("sts"), "IsNwOnTrigger", Constant(isNWOnTrigger))
.SetProperty(Ref("sts"), "StreamCountOuter", Constant(streamCountOuter))
.SetProperty(Ref("sts"), "LookupExpressions", Constant(LookupStrategyDesc.ExpressionsTexts))
.MethodReturn(Ref("sts"));
return LocalMethod(methodNode);
}
private CodegenMethod GetCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(typeof(GenericRecord), "record")
.Block
.DeclareVar<GenericRecord>(
"inner",
StaticMethod(
GetType(),
"GetAtIndex",
Ref("record"),
Constant(_posTop.Name),
Constant(_index)))
.IfRefNullReturnNull("inner")
.MethodReturn(
_nested.UnderlyingGetCodegen(
Ref("inner"),
codegenMethodScope,
codegenClassScope));
}
