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