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