public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(FireAndForgetProcessorTable), GetType(), classScope); var nw = Ref("tbl"); method.Block .DeclareVar<FireAndForgetProcessorTable>( nw.Ref, NewInstance(typeof(FireAndForgetProcessorTable))) .SetProperty( nw, "Table", TableDeployTimeResolver.MakeResolveTable(Table, symbols.GetAddInitSvc(method))) .MethodReturn(nw); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.MakeChild(typeof(PropertyEvaluatorAccumulative), this.GetType(), classScope); method.Block .DeclareVar<PropertyEvaluatorAccumulative>("pe", NewInstance(typeof(PropertyEvaluatorAccumulative))) .SetProperty( Ref("pe"), "ContainedEventEvals", MakeContained(containedEventEvals, method, symbols, classScope)) .SetProperty(Ref("pe"), "WhereClauses", MakeWhere(whereClauses, method, symbols, classScope)) .SetProperty(Ref("pe"), "PropertyNames", Constant(propertyNames.ToArray())) .SetProperty(Ref("pe"), "FragmentEventTypeIsIndexed", Constant(fragmentEventTypeIsIndexed)) .MethodReturn(Ref("pe")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(StreamJoinAnalysisResultRuntime), GetType(), classScope); method.Block .DeclareVar<StreamJoinAnalysisResultRuntime>( "ar", NewInstance(typeof(StreamJoinAnalysisResultRuntime))) .SetProperty(Ref("ar"), "IsPureSelfJoin", Constant(IsPureSelfJoin)) .SetProperty(Ref("ar"), "Unidirectional", Constant(UnidirectionalInd)) .SetProperty(Ref("ar"), "UnidirectionalNonDriving", Constant(_unidirectionalNonDriving)) .SetProperty(Ref("ar"), "NamedWindows", MakeNamedWindows(method, symbols)) .SetProperty(Ref("ar"), "Tables", MakeTables(method, symbols)) .MethodReturn(Ref("ar")); return LocalMethod(method); }
protected override void InlineCodegen( CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { method.Block.DeclareVar<EvalFactoryNode[]>( "children", NewArrayByLength(typeof(EvalFactoryNode), Constant(ChildNodes.Count))); for (var i = 0; i < ChildNodes.Count; i++) { method.Block.AssignArrayElement( Ref("children"), Constant(i), LocalMethod(ChildNodes[i].MakeCodegen(method, symbols, classScope))); } method.Block .SetProperty(Ref("node"), "Children", Ref("children")); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(HistoricalIndexLookupStrategyHash), GetType(), classScope); var evaluator = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey( _evaluators, _coercionTypes, _multiKeyClassRef, method, classScope); method.Block .DeclareVar<HistoricalIndexLookupStrategyHash>( "strat", NewInstance(typeof(HistoricalIndexLookupStrategyHash))) .SetProperty(Ref("strat"), "LookupStream", Constant(_lookupStream)) .SetProperty(Ref("strat"), "Evaluator", evaluator) .MethodReturn(Ref("strat")); return LocalMethod(method); }
public CodegenExpression CodegenCreateReader( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(AggregationMethodLinearWindow), GetType(), classScope); method.Block .DeclareVar(typeof(AggregationMethodLinearWindow), "strat", NewInstance(typeof(AggregationMethodLinearWindow))) .SetProperty(Ref("strat"), "ComponentType", Constant(arrayType.GetElementType())) .SetProperty( Ref("strat"), "OptionalEvaluator", optionalEvaluator == null ? ConstantNull() : ExprNodeUtilityCodegen.CodegenEvaluator(optionalEvaluator.Forge, method, GetType(), classScope)) .MethodReturn(Ref("strat")); return LocalMethod(method); }
public CodegenExpression CodegenCreateReader( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(AggregationMethodLinearFirstLastIndex), GetType(), classScope); var optionalIndexExpr = optionalIndexEval == null ? ConstantNull() : ExprNodeUtilityCodegen.CodegenEvaluator(optionalIndexEval.Forge, method, GetType(), classScope); method.Block .DeclareVar(typeof(AggregationMethodLinearFirstLastIndex), "strat", NewInstance(typeof(AggregationMethodLinearFirstLastIndex))) .SetProperty(Ref("strat"), "AccessType", Constant(accessType)) .SetProperty(Ref("strat"), "OptionalConstIndex", Constant(optionalConstant)) .SetProperty(Ref("strat"), "OptionalIndexEval", optionalIndexExpr) .MethodReturn(Ref("strat")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(ContextConditionDescriptorFilter), GetType(), classScope); method.Block .DeclareVar<ContextConditionDescriptorFilter>( "condition", NewInstance(typeof(ContextConditionDescriptorFilter))) .SetProperty( Ref("condition"), "FilterSpecActivatable", LocalMethod(FilterSpecCompiled.MakeCodegen(method, symbols, classScope))) .SetProperty(Ref("condition"), "OptionalFilterAsName", Constant(OptionalFilterAsName)) .MethodReturn(Ref("condition")); return LocalMethod(method); }
private CodegenExpression MakeWriters( InternalEventRouterWriterForge[] writers, CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var init = new CodegenExpression[writers.Length]; for (int i = 0; i < init.Length; i++) { if (writers[i] != null) { init[i] = writers[i].Codegen(writers[i], method, symbols, classScope); } else { init[i] = ConstantNull(); } } return NewArrayWithInit(typeof(InternalEventRouterWriter), init); }
public static CodegenExpressionInstanceField MakeVariableField( VariableMetaData variableMetaData, CodegenClassScope classScope, Type generator) { var symbols = new SAIFFInitializeSymbol(); var variableInit = classScope.NamespaceScope.InitMethod .MakeChildWithScope(typeof(Variable), generator, symbols, classScope) .AddParam( typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref); variableInit.Block.MethodReturn( MakeResolveVariable(variableMetaData, EPStatementInitServicesConstants.REF)); return classScope.NamespaceScope.AddDefaultFieldUnshared( true, typeof(Variable), LocalMethod(variableInit, EPStatementInitServicesConstants.REF)); }
public void ProvideCodegen( CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var factory = Ref("factory"); method.Block .DeclareVar<OutputProcessViewDirectFactory>( factory.Ref, NewInstance(typeof(OutputProcessViewDirectFactory))) .SetProperty( factory, "PostProcessFactory", _outputStrategyPostProcessForge == null ? ConstantNull() : _outputStrategyPostProcessForge.Make(method, symbols, classScope)) .MethodReturn(factory); }
private static CodegenExpression MakeVariables( VariableMetaData[] variables, CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(Variable[]), typeof(VariableReadWritePackageForge), classScope); method.Block.DeclareVar <Variable[]>("vars", NewArrayByLength(typeof(Variable), Constant(variables.Length))); for (var i = 0; i < variables.Length; i++) { var resolve = VariableDeployTimeResolver.MakeResolveVariable(variables[i], symbols.GetAddInitSvc(method)); method.Block.AssignArrayElement("vars", Constant(i), resolve); } method.Block.MethodReturn(Ref("vars")); return(LocalMethod(method)); }
public CodegenExpression CodegenCreateReader( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.MakeChild(typeof(AggregationMultiFunctionAggregationMethod), GetType(), classScope); method.Block .DeclareVar <ExprEvaluator>("keyEval", ExprNodeUtilityCodegen.CodegenEvaluator(_key.Forge, method, GetType(), classScope)) .MethodReturn( StaticMethod( typeof(AggregationMethodSortedKeyedFactory), "MakeSortedAggregationWithKey", Ref("keyEval"), EnumValue(typeof(AggregationMethodSortedEnum), _aggMethod.GetName()), Constant(_underlyingClass))); return(LocalMethod(method)); }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbol symbols) { CodegenMethod method = parent.MakeChild( typeof(ContextControllerInitTermFactory), this.GetType(), classScope); method.Block .DeclareVar<ContextControllerInitTermFactory>( "factory", ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.CONTEXTSERVICEFACTORY) .Add("InitTermFactory")) .SetProperty(Ref("factory"), "InitTermSpec", detail.MakeCodegen(method, symbols, classScope)) .MethodReturn(Ref("factory")); return method; }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { return new SAIFFInitializeBuilder( OP_PACKAGE_NAME + ".epstatementsource.EPStatementSourceFactory", this.GetType(), "stmtSrc", parent, symbols, classScope) .Exprnode("statementDeploymentId", statementDeploymentId) .Exprnode("statementName", statementName) .Map<object>("statementFilter", statementFilter) .Map<object>("collector", collector) .Constant("IsSubmitEventBean", submitEventBean) .Build(); }
public void ProvideCodegen( CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { method.Block.MethodReturn( NewInstance<OutputProcessViewDirectDistinctOrAfterFactory>( _outputStrategyPostProcessForge == null ? ConstantNull() : _outputStrategyPostProcessForge.Make(method, symbols, classScope), Constant(_isDistinct), MultiKeyCodegen.CodegenGetterEventDistinct( _isDistinct, ResultEventType, DistinctMultiKey, method, classScope), AfterTimePeriod == null ? ConstantNull() : AfterTimePeriod.TimePeriodComputeForge.MakeEvaluator(method, classScope), Constant(AfterConditionNumberOfEvents), EventTypeUtility.ResolveTypeCodegen(ResultEventType, symbols.GetAddInitSvc(method)))); }
private static CodegenExpression MakeWriters( VariableTriggerWriteForge[] writers, CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(VariableTriggerWrite[]), typeof(VariableReadWritePackageForge), classScope); method.Block.DeclareVar <VariableTriggerWrite[]>("writers", NewArrayByLength(typeof(VariableTriggerWrite), Constant(writers.Length))); for (var i = 0; i < writers.Length; i++) { var writer = writers[i] == null?ConstantNull() : writers[i].Make(method, symbols, classScope); method.Block.AssignArrayElement("writers", Constant(i), writer); } method.Block.MethodReturn(Ref("writers")); return(LocalMethod(method)); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(HistoricalIndexLookupStrategyInKeywordSingle), GetType(), classScope); method.Block .DeclareVar<HistoricalIndexLookupStrategyInKeywordSingle>( "strat", NewInstance(typeof(HistoricalIndexLookupStrategyInKeywordSingle))) .SetProperty(Ref("strat"), "LookupStream", Constant(lookupStream)) .SetProperty( Ref("strat"), "Evaluators", ExprNodeUtilityCodegen.CodegenEvaluators(evaluators, method, GetType(), classScope)) .MethodReturn(Ref("strat")); return LocalMethod(method); }
public CodegenMethod InitializeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryUpdate), GetType(), classScope); method.Block .DeclareVar<StatementAgentInstanceFactoryUpdate>( "saiff", NewInstance(typeof(StatementAgentInstanceFactoryUpdate))) .SetProperty(Ref("saiff"), "Desc", forge.Make(method, symbols, classScope)) .SetProperty( Ref("saiff"), "Subselects", SubSelectFactoryForge.CodegenInitMap(subselects, GetType(), method, symbols, classScope)) .Expression(ExprDotMethodChain(symbols.GetAddInitSvc(method)).Add("AddReadyCallback", Ref("saiff"))) .MethodReturn(Ref("saiff")); return method; }
public CodegenMethod InitializeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateDataflow), GetType(), classScope); method.Block .DeclareVar<StatementAgentInstanceFactoryCreateDataflow>( "saiff", NewInstance(typeof(StatementAgentInstanceFactoryCreateDataflow))) .SetProperty( Ref("saiff"), "EventType", EventTypeUtility.ResolveTypeCodegen(eventType, symbols.GetAddInitSvc(method))) .SetProperty(Ref("saiff"), "Dataflow", dataflowForge.Make(method, symbols, classScope)) .Expression(ExprDotMethodChain(symbols.GetAddInitSvc(method)).Add("AddReadyCallback", Ref("saiff"))) .MethodReturn(Ref("saiff")); return method; }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(SubordWMatchExprLookupStrategyFactory), GetType(), classScope); method.Block .DeclareVar<ExprEvaluator>( "eval", ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(exprForge, method, GetType(), classScope)) .DeclareVar<SubordTableLookupStrategyFactory>( "lookup", OptionalInnerStrategy.Make(method, symbols, classScope)) .MethodReturn( NewInstance<SubordWMatchExprLookupStrategyIndexedFilteredFactory>( Ref("eval"), Ref("lookup"))); return LocalMethod(method); }
public void MakeMethod( CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenExpressionRef queryMethod = Ref("qm"); method.Block .DeclareVar(TypeOfMethod(), queryMethod.Ref, NewInstance(TypeOfMethod())) .SetProperty( queryMethod, "Annotations", annotations == null ? ConstantNull() : LocalMethod(MakeAnnotations(typeof(Attribute[]), annotations, method, classScope))) .SetProperty( queryMethod, "Processor", processor.Make(method, symbols, classScope)) .SetProperty( queryMethod, "QueryGraph", queryGraph == null ? ConstantNull() : queryGraph.Make(method, symbols, classScope)) .SetProperty( queryMethod, "InternalEventRouteDest", ExprDotName( symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.INTERNALEVENTROUTEDEST)) .SetProperty( queryMethod, "TableAccesses", ExprTableEvalStrategyUtil.CodegenInitMap( tableAccessForges, this.GetType(), method, symbols, classScope)) .SetProperty( queryMethod, "HasTableAccess", Constant(hasTableAccess)) .SetProperty( queryMethod, "Subselects", SubSelectFactoryForge.CodegenInitMap( _subselectForges, GetType(), method, symbols, classScope)); MakeInlineSpecificSetter(queryMethod, method, symbols, classScope); method.Block.MethodReturn(queryMethod); }
public CodegenExpression MakeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(ContextControllerDetailHashItem), GetType(), classScope); method.Block.DeclareVar<EventType>( "eventType", EventTypeUtility.ResolveTypeCodegen( FilterSpecCompiled.FilterForEventType, symbols.GetAddInitSvc(method))); var symbolsWithType = new SAIFFInitializeSymbolWEventType(); var methodLookupableMake = parent.MakeChildWithScope( typeof(ExprFilterSpecLookupable), GetType(), symbolsWithType, classScope) .AddParam(typeof(EventType), "eventType") .AddParam(typeof(EPStatementInitServices), SAIFFInitializeSymbol.REF_STMTINITSVC.Ref); var methodLookupable = Lookupable.MakeCodegen(methodLookupableMake, symbolsWithType, classScope); methodLookupableMake.Block.MethodReturn(LocalMethod(methodLookupable)); method.Block .DeclareVar<ContextControllerDetailHashItem>( "item", NewInstance(typeof(ContextControllerDetailHashItem))) .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(methodLookupableMake, Ref("eventType"), symbols.GetAddInitSvc(method))) .SetProperty( Ref("item"), "FilterSpecActivatable", LocalMethod(FilterSpecCompiled.MakeCodegen(method, symbols, classScope))) .SetProperty(Ref("item"), "Lookupable", Ref("lookupable")) .Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY) .Add("RegisterLookupable", Ref("eventType"), Ref("lookupable"))) .MethodReturn(Ref("item")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(VariableReadWritePackage), GetType(), classScope); var @ref = Ref("rw"); method.Block .DeclareVar <VariableReadWritePackage>(@ref.Ref, NewInstance <VariableReadWritePackage>()) .SetProperty(@ref, "CopyMethods", MakeCopyMethods(_copyMethods, method, symbols, classScope)) .SetProperty(@ref, "Assignments", MakeAssignments(_assignments, _variables, method, symbols, classScope)) .SetProperty(@ref, "Variables", MakeVariables(_variables, method, symbols, classScope)) .SetProperty(@ref, "Writers", MakeWriters(_writers, method, symbols, classScope)) .SetProperty(@ref, "ReadersForGlobalVars", MakeReadersForGlobalVars(_variables, method, symbols, classScope)) .SetProperty(@ref, "MustCoerce", Constant(_mustCoerce)) .MethodReturn(@ref); return(LocalMethod(method)); }
public CodegenExpression Make( CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var resolveTable = table == null ? ConstantNull() : TableDeployTimeResolver.MakeResolveTable(table, symbols.GetAddInitSvc(method)); var insertIntoStreamSelectorExpr = insertIntoStreamSelector == null ? ConstantNull() : EnumValue(typeof(SelectClauseStreamSelectorEnum), insertIntoStreamSelector.Value.GetName()); return NewInstance<OutputStrategyPostProcessFactory>( Constant(isRouted), insertIntoStreamSelectorExpr, EnumValue(typeof(SelectClauseStreamSelectorEnum), selectStreamSelector.GetName()), Constant(routeToFront), resolveTable); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(EvalClass, GetType(), classScope); method.Block .DeclareVar(EvalClass, "eval", NewInstance(EvalClass)) .SetProperty(Ref("eval"), "NodeNumNested", Constant(NodeNumNested)) .SetProperty(Ref("eval"), "VariableName", Constant(VariableName)) .SetProperty(Ref("eval"), "StreamNum", Constant(StreamNum)) .SetProperty(Ref("eval"), "IsMultiple", Constant(IsMultiple)) .SetProperty(Ref("eval"), "IsGreedy", Constant(IsGreedy)) .SetProperty(Ref("eval"), "NodeNumFlat", Constant(NodeNumFlat)) .SetProperty(Ref("eval"), "IsExprRequiresMultimatchState", Constant(exprRequiresMultimatchState)); AssignInline(Ref("eval"), method, symbols, classScope); method.Block.MethodReturn(Ref("eval")); return LocalMethod(method); }
protected override CodegenMethod CodegenConstructorInit( CodegenMethodScope parent, CodegenClassScope classScope) { var saiffInitializeSymbol = new SAIFFInitializeSymbol(); CodegenMethod method = parent .MakeChildWithScope(TypeOfFactory(), GetType(), saiffInitializeSymbol, classScope) .AddParam( typeof(EPStatementInitServices), REF_STMTINITSVC.Ref); method.Block .ExprDotMethod( REF_STMTINITSVC, "ActivateContext", Constant(contextName), GetDefinition(method, saiffInitializeSymbol, classScope)) .MethodReturn(LocalMethod(forge.InitializeCodegen(classScope, method, saiffInitializeSymbol))); return method; }
public override CodegenExpression Codegen( InternalEventRouterWriterForge writer, CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(InternalEventRouterWriterCurly), GetType(), classScope); var descExpr = ExprNodeUtilityCodegen.CodegenEvaluator( _expression.Forge, method, typeof(VariableTriggerWriteArrayElementForge), classScope); method.Block .DeclareVar<InternalEventRouterWriterCurly>("desc", NewInstance(typeof(InternalEventRouterWriterCurly))) .SetProperty(Ref("desc"), "Expression", descExpr) .MethodReturn(Ref("desc")); return LocalMethod(method); }
protected internal static CodegenExpression MakeWhere( ExprForge[] whereClauses, CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenExpression[] expressions = new CodegenExpression[whereClauses.Length]; for (int i = 0; i < whereClauses.Length; i++) { expressions[i] = whereClauses[i] == null ? ConstantNull() : ExprNodeUtilityCodegen.CodegenEvaluator( whereClauses[i], method, typeof(PropertyEvaluatorAccumulativeForge), classScope); } return NewArrayWithInit(typeof(ExprEvaluator), expressions); }
public CodegenMethod InitializeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbol symbols) { var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateContext), GetType(), classScope); method.Block .DeclareVar<StatementAgentInstanceFactoryCreateContext>( "saiff", NewInstance(typeof(StatementAgentInstanceFactoryCreateContext))) .SetProperty(Ref("saiff"), "ContextName", Constant(contextName)) .SetProperty( Ref("saiff"), "StatementEventType", EventTypeUtility.ResolveTypeCodegen(statementEventType, symbols.GetAddInitSvc(method))) .ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff")) .MethodReturn(Ref("saiff")); return method; }