protected override void CodegenInlineSetWFilterWInputType( CodegenExpressionRef @ref, CodegenMethod method, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { }
protected override CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(TableMetadataColumnAggregation), GetType(), classScope); method.Block.DeclareVar<TableMetadataColumnAggregation>( "col", NewInstance(typeof(TableMetadataColumnAggregation))); base.MakeSettersInline(Ref("col"), method.Block); method.Block .SetProperty(Ref("col"), "Column", Constant(Column)) .SetProperty( Ref("col"), "AggregationPortableValidation", AggregationPortableValidation.Make(method, symbols, classScope)) .SetProperty(Ref("col"), "AggregationExpression", Constant(AggregationExpression)) .SetProperty(Ref("col"), "IsMethodAgg", Constant(IsMethodAgg)) .SetProperty( Ref("col"), "OptionalEnumerationType", OptionalEnumerationType == null ? ConstantNull() : OptionalEnumerationType.Codegen(method, classScope, symbols.GetAddInitSvc(method))) .MethodReturn(Ref("col")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(TableMetaData), GetType(), classScope); method.Block .DeclareVar<TableMetaData>("meta", NewInstance(typeof(TableMetaData))) .SetProperty(Ref("meta"), "TableName", Constant(TableName)) .SetProperty(Ref("meta"), "TableModuleName", Constant(TableModuleName)) .SetProperty(Ref("meta"), "TableVisibility", Constant(TableVisibility)) .SetProperty(Ref("meta"), "OptionalContextName", Constant(OptionalContextName)) .SetProperty(Ref("meta"), "OptionalContextVisibility", Constant(OptionalContextVisibility)) .SetProperty(Ref("meta"), "OptionalContextModule", Constant(OptionalContextModule)) .SetProperty( Ref("meta"), "InternalEventType", EventTypeUtility.ResolveTypeCodegen(InternalEventType, symbols.GetAddInitSvc(method))) .SetProperty( Ref("meta"), "PublicEventType", EventTypeUtility.ResolveTypeCodegen(PublicEventType, symbols.GetAddInitSvc(method))) .SetProperty(Ref("meta"), "KeyColumns", Constant(KeyColumns)) .SetProperty(Ref("meta"), "KeyTypes", Constant(KeyTypes)) .SetProperty(Ref("meta"), "KeyColNums", Constant(KeyColNums)) .SetProperty( Ref("meta"), "Columns", TableMetadataColumn.MakeColumns(Columns, method, symbols, classScope)) .SetProperty(Ref("meta"), "NumMethodAggs", Constant(NumMethodAggs)) .ExprDotMethod(Ref("meta"), "Init") .MethodReturn(Ref("meta")); return LocalMethod(method); }
protected override void CodegenInlineSetWFilterWInputType( CodegenExpressionRef @ref, CodegenMethod method, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { method.Block.SetProperty(@ref, "Size", Constant(Size)); }
protected override void CodegenInlineSet( CodegenExpressionRef @ref, CodegenMethod method, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { method.Block.SetProperty(@ref, "FunctionName", Constant(_functionName)); }
protected override void CodegenInlineSet( CodegenExpressionRef @ref, CodegenMethod method, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { method.Block .SetProperty(Ref("v"), "InputValueType", Constant(InputValueType)) .SetProperty(Ref("v"), "HasFilter", Constant(HasFilter)); CodegenInlineSetWFilterWInputType(@ref, method, symbols, classScope); }
public CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(TypeOf(), GetType(), classScope); method.Block .DeclareVar(TypeOf(), "v", NewInstance(TypeOf())) .SetProperty(Ref("v"), "IsDistinct", Constant(IsDistinct)); CodegenInlineSet(Ref("v"), method, symbols, classScope); method.Block.MethodReturn(Ref("v")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(AggregationPortableValidationPluginMultiFunc), GetType(), classScope); method.Block .DeclareVar<AggregationPortableValidationPluginMultiFunc>("portable", NewInstance(typeof(AggregationPortableValidationPluginMultiFunc))) .SetProperty(Ref("portable"), "AggregationFunctionName", Constant(AggregationFunctionName)) .SetProperty(Ref("portable"), "Config", Config == null ? ConstantNull() : Config.ToExpression()) .MethodReturn(Ref("portable")); return LocalMethod(method); }
protected override CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(TableMetadataColumnPlain), GetType(), classScope); method.Block.DeclareVar<TableMetadataColumnPlain>( "col", NewInstance(typeof(TableMetadataColumnPlain))); base.MakeSettersInline(Ref("col"), method.Block); method.Block .SetProperty(Ref("col"), "IndexPlain", Constant(IndexPlain)) .MethodReturn(Ref("col")); return LocalMethod(method); }
public CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(AggregationPortableValidationLinear), GetType(), classScope); method.Block .DeclareVar<AggregationPortableValidationLinear>( "v", NewInstance(typeof(AggregationPortableValidationLinear))) .SetProperty( Ref("v"), "ContainedEventType", EventTypeUtility.ResolveTypeCodegen(ContainedEventType, symbols.GetAddInitSvc(method))) .MethodReturn(Ref("v")); return LocalMethod(method); }
private static CodegenMethod RegisterTableCodegen( KeyValuePair<string, TableMetaData> table, CodegenMethodScope parent, CodegenClassScope classScope, ModuleTableInitializeSymbol symbols) { var method = parent.MakeChild(typeof(void), typeof(EPCompilerImpl), classScope); method.Block .DeclareVar<TableMetaData>("detail", table.Value.Make(parent, symbols, classScope)) .Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPModuleTableInitServicesConstants.GETTABLECOLLECTOR) .Add( "RegisterTable", Constant(table.Key), Ref("detail"))); return method; }
public static CodegenExpression MakeColumns( IDictionary<string, TableMetadataColumn> columns, CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild( typeof(IDictionary<string, TableMetadataColumn>), typeof(TableMetadataColumn), classScope); method.Block.DeclareVar<IDictionary<string, TableMetadataColumn>>( "cols", NewInstance(typeof(Dictionary<string, TableMetadataColumn>))); foreach (KeyValuePair<string, TableMetadataColumn> entry in columns) { method.Block.ExprDotMethod( Ref("cols"), "Put", Constant(entry.Key), entry.Value.Make(method, symbols, classScope)); } method.Block.MethodReturn(Ref("cols")); return LocalMethod(method); }
protected abstract void CodegenInlineSet( CodegenExpressionRef @ref, CodegenMethod method, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope);
protected abstract CodegenExpression Make( CodegenMethodScope parent, ModuleTableInitializeSymbol symbols, CodegenClassScope classScope);
private static string CompileModule( string optionalModuleName, IDictionary<ModuleProperty, object> moduleProperties, IList<string> statementClassNames, string moduleIdentPostfix, ModuleCompileTimeServices compileTimeServices, out Assembly assembly) { // write code to create an implementation of StatementResource var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), moduleIdentPostfix); var namespaceScope = new CodegenNamespaceScope( compileTimeServices.Namespace, statementFieldsClassName, compileTimeServices.IsInstrumented()); var moduleClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(ModuleProvider), moduleIdentPostfix); var classScope = new CodegenClassScope(true, namespaceScope, moduleClassName); var methods = new CodegenClassMethods(); var properties = new CodegenClassProperties(); // provide module name var moduleNameProp = CodegenProperty.MakePropertyNode( typeof(string), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); moduleNameProp.GetterBlock.BlockReturn(Constant(optionalModuleName)); // provide module properties var modulePropertiesProp = CodegenProperty.MakePropertyNode( typeof(IDictionary<ModuleProperty, object>), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); MakeModuleProperties(moduleProperties, modulePropertiesProp); // provide module dependencies var moduleDependenciesProp = CodegenProperty.MakePropertyNode( typeof(ModuleDependenciesRuntime), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); compileTimeServices.ModuleDependencies.Inject(moduleDependenciesProp.GetterBlock); // register types var initializeEventTypesMethod = MakeInitEventTypes(classScope, compileTimeServices); // register named windows var symbolsNamedWindowInit = new ModuleNamedWindowInitializeSymbol(); var initializeNamedWindowsMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsNamedWindowInit, classScope) .AddParam( typeof(EPModuleNamedWindowInitServices), ModuleNamedWindowInitializeSymbol.REF_INITSVC.Ref); foreach (var namedWindow in compileTimeServices.NamedWindowCompileTimeRegistry.NamedWindows) { var addNamedWindow = RegisterNamedWindowCodegen( namedWindow, initializeNamedWindowsMethod, classScope, symbolsNamedWindowInit); initializeNamedWindowsMethod.Block.Expression(LocalMethod(addNamedWindow)); } // register tables var symbolsTableInit = new ModuleTableInitializeSymbol(); var initializeTablesMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsTableInit, classScope) .AddParam(typeof(EPModuleTableInitServices), ModuleTableInitializeSymbol.REF_INITSVC.Ref); foreach (var table in compileTimeServices.TableCompileTimeRegistry.Tables) { var addTable = RegisterTableCodegen(table, initializeTablesMethod, classScope, symbolsTableInit); initializeTablesMethod.Block.Expression(LocalMethod(addTable)); } // register indexes var symbolsIndexInit = new ModuleIndexesInitializeSymbol(); var initializeIndexesMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsIndexInit, classScope) .AddParam(typeof(EPModuleIndexInitServices), EPModuleIndexInitServicesConstants.REF.Ref); foreach (KeyValuePair<IndexCompileTimeKey, IndexDetailForge> index in compileTimeServices .IndexCompileTimeRegistry.Indexes) { var addIndex = RegisterIndexCodegen(index, initializeIndexesMethod, classScope, symbolsIndexInit); initializeIndexesMethod.Block.Expression(LocalMethod(addIndex)); } // register contexts var symbolsContextInit = new ModuleContextInitializeSymbol(); var initializeContextsMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsContextInit, classScope) .AddParam( typeof(EPModuleContextInitServices), ModuleContextInitializeSymbol.REF_INITSVC.Ref); foreach (var context in compileTimeServices.ContextCompileTimeRegistry.Contexts) { var addContext = RegisterContextCodegen( context, initializeContextsMethod, classScope, symbolsContextInit); initializeContextsMethod.Block.Expression(LocalMethod(addContext)); } // register variables var symbolsVariablesInit = new ModuleVariableInitializeSymbol(); var initializeVariablesMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsVariablesInit, classScope) .AddParam( typeof(EPModuleVariableInitServices), ModuleVariableInitializeSymbol.REF_INITSVC.Ref); foreach (var variable in compileTimeServices.VariableCompileTimeRegistry.Variables) { var addVariable = RegisterVariableCodegen( variable, initializeVariablesMethod, classScope, symbolsVariablesInit); initializeVariablesMethod.Block.Expression(LocalMethod(addVariable)); } // register expressions var symbolsExprDeclaredInit = new ModuleExpressionDeclaredInitializeSymbol(); var initializeExprDeclaredMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsExprDeclaredInit, classScope) .AddParam( typeof(EPModuleExprDeclaredInitServices), ModuleExpressionDeclaredInitializeSymbol.REF_INITSVC.Ref); foreach (var expression in compileTimeServices.ExprDeclaredCompileTimeRegistry.Expressions) { var addExpression = RegisterExprDeclaredCodegen( expression, initializeExprDeclaredMethod, classScope, symbolsExprDeclaredInit); initializeExprDeclaredMethod.Block.Expression(LocalMethod(addExpression)); } // register scripts var symbolsScriptInit = new ModuleScriptInitializeSymbol(); var initializeScriptsMethod = CodegenMethod .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsScriptInit, classScope) .AddParam(typeof(EPModuleScriptInitServices), ModuleScriptInitializeSymbol.REF_INITSVC.Ref); foreach (var expression in compileTimeServices.ScriptCompileTimeRegistry.Scripts) { var addScript = RegisterScriptCodegen( expression, initializeScriptsMethod, classScope, symbolsScriptInit); initializeScriptsMethod.Block.Expression(LocalMethod(addScript)); } // register provided classes var symbolsClassProvidedInit = new ModuleClassProvidedInitializeSymbol(); var initializeClassProvidedMethod = CodegenMethod .MakeParentNode(typeof(void), typeof(EPCompilerImpl), symbolsClassProvidedInit, classScope) .AddParam(typeof(EPModuleClassProvidedInitServices), ModuleClassProvidedInitializeSymbol.REF_INITSVC.Ref); foreach (var currClazz in compileTimeServices.ClassProvidedCompileTimeRegistry.Classes) { var addClassProvided = RegisterClassProvidedCodegen( currClazz, initializeClassProvidedMethod, classScope, symbolsClassProvidedInit); initializeClassProvidedMethod.Block.Expression(LocalMethod(addClassProvided)); } // instantiate factories for statements var statementsProp = CodegenProperty.MakePropertyNode( typeof(IList<StatementProvider>), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); statementsProp.GetterBlock.DeclareVar<IList<StatementProvider>>( "statements", NewInstance(typeof(List<StatementProvider>), Constant(statementClassNames.Count))); foreach (var statementClassName in statementClassNames) { statementsProp.GetterBlock.ExprDotMethod( Ref("statements"), "Add", NewInstanceInner(statementClassName)); } statementsProp.GetterBlock.BlockReturn(Ref("statements")); // build stack CodegenStackGenerator.RecursiveBuildStack( moduleNameProp, "ModuleName", methods, properties); CodegenStackGenerator.RecursiveBuildStack( modulePropertiesProp, "ModuleProperties", methods, properties); CodegenStackGenerator.RecursiveBuildStack( moduleDependenciesProp, "ModuleDependencies", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeEventTypesMethod, "InitializeEventTypes", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeNamedWindowsMethod, "InitializeNamedWindows", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeTablesMethod, "InitializeTables", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeIndexesMethod, "InitializeIndexes", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeContextsMethod, "InitializeContexts", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeVariablesMethod, "InitializeVariables", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeExprDeclaredMethod, "InitializeExprDeclareds", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeScriptsMethod, "InitializeScripts", methods, properties); CodegenStackGenerator.RecursiveBuildStack( initializeClassProvidedMethod, "InitializeClassProvided", methods, properties); CodegenStackGenerator.RecursiveBuildStack( statementsProp, "Statements", methods, properties); var clazz = new CodegenClass( CodegenClassType.MODULEPROVIDER, typeof(ModuleProvider), moduleClassName, classScope, new EmptyList<CodegenTypedParam>(), null, methods, properties, new EmptyList<CodegenInnerClass>()); var container = compileTimeServices.Container; var compiler = container .RoslynCompiler() .WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode) .WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory) .WithCodegenClasses(new[] {clazz}); assembly = compiler.Compile(); return CodeGenerationIDGenerator.GenerateClassNameWithNamespace( compileTimeServices.Namespace, typeof(ModuleProvider), moduleIdentPostfix); }