public Type CompileStandInClass( CodegenClassType classType, string classNameSimple, ModuleCompileTimeServices services) { var namespaceScope = new CodegenNamespaceScope(services.Namespace, null, false); var classScope = new CodegenClassScope(true, namespaceScope, null); var clazz = new CodegenClass( classType, null, classNameSimple, classScope, EmptyList<CodegenTypedParam>.Instance, null, new CodegenClassMethods(), new CodegenClassProperties(), EmptyList<CodegenInnerClass>.Instance); // This is a bit hacky... basically, Esper has to generate a "Type" that can be returned and // included as the "Underlying" type for the JsonEventType. This method is called during the // portion of the sequence where we are attempting to build the forgeables, so the real type // doesnt exist yet. Esper builds the stand-in but expects that the real type will be used // at runtime. In Java, type erasure allows this to happen because there is no real type in // backing arrays and collections. In .NET we need the types to match. // // We are creating a "capsule" class which will act as a placeholder. When we detect that // the type is a capsule type in the JsonEventType, we will attempt to "resolve" and replace // it. var classNameFull = namespaceScope.Namespace + '.' + classNameSimple; var capsuleClass = CapsuleEmitter.CreateCapsule(classNameFull); return capsuleClass.TargetType; }
public CodegenClass Forge( bool includeDebugSymbols, bool fireAndForget) { var properties = new CodegenClassProperties(); var methods = new CodegenClassMethods(); var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, _className); // -------------------------------------------------------------------------------- // void Serialize(JsonSerializationContext context, object underlying) // -------------------------------------------------------------------------------- var serializeMethod = CodegenMethod .MakeParentNode(typeof(void), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(JsonSerializationContext), "context") .AddParam(typeof(object), "underlying"); MakeSerialize(serializeMethod, classScope); CodegenStackGenerator.RecursiveBuildStack(serializeMethod, "Serialize", methods, properties); var clazz = new CodegenClass( _classType, _className, classScope, EmptyList <CodegenTypedParam> .Instance, null, methods, properties, EmptyList <CodegenInnerClass> .Instance); clazz.BaseList.AssignType(typeof(IJsonSerializer)); return(clazz); }
public static string Compile(CodegenClass clazz) { // build members and imports var classes = clazz.GetReferencedClasses(); var imports = CompileImports(classes); // generate code return GenerateCode(imports, clazz); }
private static void RefactorMethodsClass( CodegenClass clazz, int maxMethodsPerClass) { var inners = clazz.InnerClasses.ToArray(); foreach (var inner in inners) { RefactorMethodsInnerClass(clazz, inner, maxMethodsPerClass); } }
public static EventPropertyGetter Compile( this ICodegenContext codegenContext, string engineURI, ClassLoaderProvider classLoaderProvider, EventPropertyGetterSPI getterSPI, string propertyExpression) { var get = getterSPI.CodegenEventBeanGet(Ref("bean"), codegenContext); var exists = getterSPI.CodegenEventBeanExists(Ref("bean"), codegenContext); var fragment = getterSPI.CodegenEventBeanFragment(Ref("bean"), codegenContext); var singleBeanParam = CodegenNamedParam.From(typeof(EventBean), "bean"); // For: public object Get(EventBean eventBean) ; // For: public bool IsExistsProperty(EventBean eventBean); // For: public object GetFragment(EventBean eventBean) ; var getMethod = new CodegenMethod(typeof(object), "Get", singleBeanParam, null); getMethod.Statements.MethodReturn(get); var isExistsPropertyMethod = new CodegenMethod(typeof(bool), "IsExistsProperty", singleBeanParam, null); isExistsPropertyMethod.Statements.MethodReturn(exists); var fragmentMethod = new CodegenMethod(typeof(object), "GetFragment", singleBeanParam, null); fragmentMethod.Statements.MethodReturn(fragment); var clazz = new CodegenClass( "com.espertech.esper.codegen.uri_" + engineURI, typeof(EventPropertyGetter).Name + "_" + CodeGenerationIDGenerator.GenerateClass(), typeof(EventPropertyGetter), codegenContext.Members, new [] { getMethod, isExistsPropertyMethod, fragmentMethod }, codegenContext.Methods ); string debugInfo = null; if (codegenContext.IsDebugEnabled) { debugInfo = getterSPI.GetType().FullName + " for property '" + propertyExpression + "'"; } return(codegenContext.Compiler.Compile( clazz, classLoaderProvider, typeof(EventPropertyGetter), debugInfo)); }
public CodegenClass Forge( bool includeDebugSymbols, bool fireAndForget) { var dynamic = NeedDynamic(); var ctor = new CodegenCtor(typeof(StmtClassForgeableJsonUnderlying), includeDebugSymbols, EmptyList <CodegenTypedParam> .Instance); if (dynamic) { ctor.Block.AssignRef(DYNAMIC_PROP_FIELD, NewInstance(typeof(LinkedHashMap <string, object>))); } var properties = new CodegenClassProperties(); var methods = new CodegenClassMethods(); var classScope = new CodegenClassScope(includeDebugSymbols, namespaceScope, className); IList <CodegenTypedParam> explicitMembers = new List <CodegenTypedParam>(desc.PropertiesThisType.Count); if (dynamic) { explicitMembers.Add(new CodegenTypedParam(typeof(IDictionary <string, object>), DYNAMIC_PROP_FIELD, false, true)); } // add members foreach (var property in desc.PropertiesThisType) { var field = desc.FieldDescriptorsInclSupertype.Get(property.Key); explicitMembers.Add(new CodegenTypedParam(field.PropertyType, field.FieldName, false, true)); } // -------------------------------------------------------------------------------- // - NativeCount => int // -------------------------------------------------------------------------------- var nativeCountProperty = CodegenProperty .MakePropertyNode(typeof(int), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); nativeCountProperty.GetterBlock .BlockReturn(Constant(desc.PropertiesThisType.Count + desc.NumFieldsSupertype)); CodegenStackGenerator.RecursiveBuildStack(nativeCountProperty, "NativeCount", methods, properties); // -------------------------------------------------------------------------------- // - TryGetNativeEntry(string, out KeyValuePair<string, object> // -------------------------------------------------------------------------------- var tryGetNativeEntryMethod = CodegenMethod .MakeParentNode(typeof(bool), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(string), "name") .AddParam(new CodegenNamedParam(typeof(KeyValuePair <string, object>), "value").WithOutputModifier()) .WithOverride(); MakeTryGetNativeEntry(tryGetNativeEntryMethod, classScope); CodegenStackGenerator.RecursiveBuildStack(tryGetNativeEntryMethod, "TryGetNativeEntry", methods, properties); // -------------------------------------------------------------------------------- // - TrySetNativeValue(string, object) // -------------------------------------------------------------------------------- var trySetNativeValueMethod = CodegenMethod .MakeParentNode(typeof(bool), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(string), "name") .AddParam(typeof(object), "value") .WithOverride(); MakeTrySetNativeValue(trySetNativeValueMethod, classScope); CodegenStackGenerator.RecursiveBuildStack(trySetNativeValueMethod, "TrySetNativeValue", methods, properties); // -------------------------------------------------------------------------------- // - NativeEnumerable => IEnumerable<KeyValuePair<string, object>> // -------------------------------------------------------------------------------- var nativeEnumerable = CodegenProperty .MakePropertyNode(typeof(IEnumerable <KeyValuePair <string, object> >), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); MakeNativeEnumerable(nativeEnumerable, classScope); CodegenStackGenerator.RecursiveBuildStack(nativeEnumerable, "NativeEnumerable", methods, properties); // -------------------------------------------------------------------------------- // - NativeContainsKey(string) // -------------------------------------------------------------------------------- var nativeContainsKeyMethod = CodegenMethod .MakeParentNode(typeof(bool), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(string), "name") .WithOverride(); MakeNativeContainsKey(nativeContainsKeyMethod); CodegenStackGenerator.RecursiveBuildStack(nativeContainsKeyMethod, "NativeContainsKey", methods, properties); // -------------------------------------------------------------------------------- // - NativeWrite(Utf8JsonWriter) // -------------------------------------------------------------------------------- var nativeWriteMethod = CodegenMethod .MakeParentNode(typeof(void), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(JsonSerializationContext), "context") .WithOverride(); MakeNativeWrite(nativeWriteMethod, classScope); CodegenStackGenerator.RecursiveBuildStack(nativeWriteMethod, "NativeWrite", methods, properties); if (!ParentDynamic() && dynamic) { // -------------------------------------------------------------------------------- // AddJsonValue // -------------------------------------------------------------------------------- var addJsonValueMethod = CodegenMethod .MakeParentNode(typeof(void), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(string), "name") .AddParam(typeof(object), "value") .WithOverride(); addJsonValueMethod.Block.ExprDotMethod(Ref(DYNAMIC_PROP_FIELD), "Put", Ref("name"), Ref("value")); CodegenStackGenerator.RecursiveBuildStack(addJsonValueMethod, "AddJsonValue", methods, properties); // - JsonValues => IDictionary<string, object> var jsonValuesProperty = CodegenProperty .MakePropertyNode(typeof(IDictionary <string, object>), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); jsonValuesProperty.GetterBlock.BlockReturn(Ref(DYNAMIC_PROP_FIELD)); CodegenStackGenerator.RecursiveBuildStack(jsonValuesProperty, "JsonValues", methods, properties); } var clazz = new CodegenClass( CodegenClassType.JSONEVENT, className, classScope, explicitMembers, ctor, methods, properties, EmptyList <CodegenInnerClass> .Instance); if (desc.OptionalSupertype == null) { clazz.BaseList.AssignType(typeof(JsonEventObjectBase)); } else { clazz.BaseList.AssignType(desc.OptionalSupertype.UnderlyingType); } return(clazz); }
private static string MakeFAFProvider( string queryMethodProviderClassName, string classPostfix, ModuleCompileTimeServices compileTimeServices, out Assembly assembly) { var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( compileTimeServices.Namespace, statementFieldsClassName, compileTimeServices.IsInstrumented()); var fafProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(FAFProvider), classPostfix); var classScope = new CodegenClassScope(true, namespaceScope, fafProviderClassName); var methods = new CodegenClassMethods(); var properties = new CodegenClassProperties(); // -------------------------------------------------------------------------------- // Add statementFields // -------------------------------------------------------------------------------- var ctor = new CodegenCtor( typeof(CompilerHelperFAFProvider), classScope, new List<CodegenTypedParam>()); ctor.Block.AssignRef(Ref("statementFields"), NewInstanceInner(statementFieldsClassName)); // initialize-event-types var initializeEventTypesMethod = MakeInitEventTypes(classScope, compileTimeServices); // initialize-query var initializeQueryMethod = CodegenMethod .MakeMethod( typeof(void), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam( typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref); initializeQueryMethod.Block.AssignMember( MEMBERNAME_QUERY_METHOD_PROVIDER, NewInstanceInner(queryMethodProviderClassName, EPStatementInitServicesConstants.REF, Ref("statementFields"))); // get-execute var queryMethodProviderProperty = CodegenProperty.MakePropertyNode( typeof(FAFQueryMethodProvider), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); queryMethodProviderProperty.GetterBlock.BlockReturn(Ref(MEMBERNAME_QUERY_METHOD_PROVIDER)); // provide module dependencies var moduleDependenciesProperty = CodegenProperty.MakePropertyNode( typeof(ModuleDependenciesRuntime), typeof(EPCompilerImpl), CodegenSymbolProviderEmpty.INSTANCE, classScope); moduleDependenciesProperty.GetterBlock .BlockReturn(compileTimeServices.ModuleDependencies.Make( initializeQueryMethod, classScope)); // build stack CodegenStackGenerator.RecursiveBuildStack(moduleDependenciesProperty, "ModuleDependencies", methods, properties); CodegenStackGenerator.RecursiveBuildStack(initializeEventTypesMethod, "InitializeEventTypes", methods, properties); CodegenStackGenerator.RecursiveBuildStack(initializeQueryMethod, "InitializeQuery", methods, properties); CodegenStackGenerator.RecursiveBuildStack(queryMethodProviderProperty, "QueryMethodProvider", methods, properties); IList<CodegenTypedParam> members = new List<CodegenTypedParam>(); members.Add(new CodegenTypedParam(statementFieldsClassName, null, "statementFields")); var typedParam = new CodegenTypedParam(typeof(FAFQueryMethodProvider), MEMBERNAME_QUERY_METHOD_PROVIDER); typedParam.IsReadonly = false; members.Add(typedParam); var clazz = new CodegenClass( CodegenClassType.FAFPROVIDER, typeof(FAFProvider), fafProviderClassName, classScope, members, ctor, 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 List<CodegenClass>() { clazz }); assembly = compiler.Compile(); return CodeGenerationIDGenerator.GenerateClassNameWithNamespace( compileTimeServices.Namespace, typeof(FAFProvider), classPostfix); }
private static string GenerateSyntax( ICollection<ImportDecl> imports, CodegenClass clazz) { var builder = new StringBuilder(); var usingsList = CodeGenerationUtil.Importsdecl(imports); var namespaceUnit = NamespaceDeclaration(ParseName(clazz.Namespace)); // Generate the class using descending construction of the class elements // relative to the syntax tree. All items should be children of the namespaceUnit. namespaceUnit = namespaceUnit.AddMembers(clazz.CodegenSyntax()); // inner classes foreach (var inner in clazz.InnerClasses) { builder.Append("\n"); INDENT.Indent(builder, 2); CodeGenerationUtil.Classimplements( builder, inner.ClassName, inner.BaseList, false, false); GenerateCodeMembers( builder, inner.ExplicitMembers, inner.Ctor, 2); GenerateCodeCtor( builder, inner.ClassName, true, inner.Ctor, 1); GenerateCodeProperties( builder, true, inner.Properties.PublicProperties, inner.Properties.PrivateProperties, 1); GenerateCodeMethods( builder, true, inner.Methods.PublicMethods, inner.Methods.PrivateMethods, 1); INDENT.Indent(builder, 1); builder.Append("}\n"); } var membersList = SingletonList<MemberDeclarationSyntax>(namespaceUnit); var compilationUnit = CompilationUnit() .WithUsings(usingsList) .WithMembers(membersList) .NormalizeWhitespace(); return compilationUnit.ToFullString(); }
private static string GenerateCode( ICollection<ImportDecl> imports, CodegenClass clazz) { var builder = new StringBuilder(); CodeGenerationUtil.Importsdecl(builder, imports); CodeGenerationUtil.NamespaceDecl(builder, clazz.Namespace); CodeGenerationUtil.Classimplements(builder, clazz.ClassName, clazz.BaseList, true, false); // members GenerateCodeMembers(builder, clazz.ExplicitMembers, clazz.OptionalCtor, 2); // ctor GenerateCodeCtor(builder, clazz.ClassName, false, clazz.OptionalCtor, 1); // properties GenerateCodeProperties(builder, false, clazz.PublicProperties, clazz.PrivateProperties, 1); // methods GenerateCodeMethods(builder, false, clazz.PublicMethods, clazz.PrivateMethods, 1); // inner classes foreach (var inner in clazz.InnerClasses) { builder.Append("\n"); INDENT.Indent(builder, 2); CodeGenerationUtil.Classimplements( builder, inner.ClassName, inner.BaseList, false, false); GenerateCodeMembers( builder, inner.ExplicitMembers, inner.Ctor, 2); GenerateCodeCtor( builder, inner.ClassName, true, inner.Ctor, 1); GenerateCodeProperties( builder, true, inner.Properties.PublicProperties, inner.Properties.PrivateProperties, 1); GenerateCodeMethods( builder, true, inner.Methods.PublicMethods, inner.Methods.PrivateMethods, 1); INDENT.Indent(builder, 1); builder.Append("}\n"); } // close builder.Append(" }\n"); // class builder.Append("}\n"); // namespace return builder.ToString(); }
public CodegenClass Forge( bool includeDebugSymbols, bool fireAndForget) { var makeVirtual = (_desc.OptionalSupertype == null); var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, _className); // make members var members = new List <CodegenTypedParam>(); // -------------------------------------------------------------------------------- // Constructor // -------------------------------------------------------------------------------- var ctorParams = new CodegenTypedParam[] {}; var ctor = new CodegenCtor(typeof(StmtClassForgeableRSPFactoryProvider), classScope, ctorParams); // -------------------------------------------------------------------------------- // Deserialize(JsonElement) // -------------------------------------------------------------------------------- var deserializeMethod = CodegenMethod //.MakeParentNode(_underlyingClassName, GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .MakeParentNode(typeof(object), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(typeof(JsonElement), JsonDeserializeRefs.INSTANCE.ElementName); deserializeMethod = MakeDeserialize(deserializeMethod, classScope, makeVirtual); // -------------------------------------------------------------------------------- // Properties (property) // -------------------------------------------------------------------------------- var propertiesProp = CodegenProperty .MakePropertyNode(typeof(ILookup <string, IJsonDeserializer>), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope); propertiesProp = makeVirtual ? propertiesProp.WithVirtual() : propertiesProp.WithOverride(); propertiesProp.GetterBlock.BlockReturn(ConstantNull()); // TBD // -------------------------------------------------------------------------------- var properties = new CodegenClassProperties(); // walk methods var methods = new CodegenClassMethods(); //CodegenStackGenerator.RecursiveBuildStack(getResultMethod, "GetResult", methods, properties); CodegenStackGenerator.RecursiveBuildStack(deserializeMethod, "Deserialize", methods, properties); CodegenStackGenerator.RecursiveBuildStack(propertiesProp, "Properties", methods, properties); var clazz = new CodegenClass( _classType, _className, classScope, members, ctor, methods, properties, EmptyList <CodegenInnerClass> .Instance); if (_desc.OptionalSupertype == null) { clazz.BaseList.AssignType(typeof(JsonCompositeDeserializer)); } else { clazz.BaseList.AssignBaseType(_desc.OptionalSupertype.Detail.DeserializerClassName); } return(clazz); }
public CodegenClass Forge( bool includeDebugSymbols, bool fireAndForget) { var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, _className); // make members var members = new List <CodegenTypedParam>(); // -------------------------------------------------------------------------------- // Constructor // -------------------------------------------------------------------------------- var ctorParams = new CodegenTypedParam[] {}; var ctor = new CodegenCtor(typeof(StmtClassForgeableRSPFactoryProvider), classScope, ctorParams); // -------------------------------------------------------------------------------- // TryGetProperty(string name, out object value) // -------------------------------------------------------------------------------- var tryGetPropertyMethod = CodegenMethod .MakeParentNode(typeof(bool), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(new CodegenNamedParam(typeof(string), "name")) .AddParam(new CodegenNamedParam(typeof(object), "underlying")) .AddParam(new CodegenNamedParam(typeof(object), "value").WithOutputModifier()); tryGetPropertyMethod = MakeTryGetProperty(tryGetPropertyMethod); // -------------------------------------------------------------------------------- // TrySetProperty(string name, object underlying, object value) // -------------------------------------------------------------------------------- var trySetPropertyMethod = CodegenMethod .MakeParentNode(typeof(bool), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(new CodegenNamedParam(typeof(string), "name")) .AddParam(new CodegenNamedParam(typeof(object), "underlying")) .AddParam(new CodegenNamedParam(typeof(object), "value")); trySetPropertyMethod = MakeTrySetProperty(trySetPropertyMethod); // -------------------------------------------------------------------------------- // object TryCopy(object source) // -------------------------------------------------------------------------------- var tryCopyMethod = CodegenMethod .MakeParentNode(typeof(object), this.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(new CodegenNamedParam(typeof(object), "source")); tryCopyMethod = MakeTryCopy(tryCopyMethod, classScope); // -------------------------------------------------------------------------------- // Allocator (property) // -------------------------------------------------------------------------------- var allocateMethod = CodegenMethod .MakeParentNode(typeof(object), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope); allocateMethod = MakeAllocate(allocateMethod); // -------------------------------------------------------------------------------- var properties = new CodegenClassProperties(); // walk methods var methods = new CodegenClassMethods(); CodegenStackGenerator.RecursiveBuildStack(tryGetPropertyMethod, "TryGetProperty", methods, properties); CodegenStackGenerator.RecursiveBuildStack(trySetPropertyMethod, "TrySetProperty", methods, properties); CodegenStackGenerator.RecursiveBuildStack(tryCopyMethod, "TryCopy", methods, properties); CodegenStackGenerator.RecursiveBuildStack(allocateMethod, "Allocate", methods, properties); var clazz = new CodegenClass( _classType, _className, classScope, members, ctor, methods, properties, EmptyList <CodegenInnerClass> .Instance); clazz.BaseList.AssignType(typeof(IJsonDelegate)); return(clazz); }
/// <summary> /// Constructor. /// </summary> /// <param name="codegenClass"></param> public SourceCodegen(CodegenClass codegenClass) { _codegenClass = codegenClass; }
private static void RefactorMethodsInnerClass( CodegenClass clazz, CodegenInnerClass inner, int maxMethodsPerClass) { if (maxMethodsPerClass < MAX_METHODS_PER_CLASS_MINIMUM) { throw new EPException( "Invalid value for maximum number of methods per class, expected a minimum of " + MAX_METHODS_PER_CLASS_MINIMUM + " but received " + maxMethodsPerClass); } var size = inner.Methods.Count; if (size <= maxMethodsPerClass) { return; } // collect static methods bottom-up ISet <CodegenMethodWGraph> collectedStaticMethods = new HashSet <CodegenMethodWGraph>(); Func <CodegenMethod, bool> permittedMethods = method => collectedStaticMethods.Contains(method.AssignedMethod); foreach (var publicMethod in inner.Methods.PublicMethods) { RecursiveBottomUpCollectStatic(publicMethod.Originator, collectedStaticMethods, permittedMethods); } // collect static methods from private methods preserving the order they appear in IList <CodegenMethodWGraph> staticMethods = new List <CodegenMethodWGraph>(); var count = -1; foreach (var privateMethod in inner.Methods.PrivateMethods) { count++; if (count < maxMethodsPerClass) { continue; } if (collectedStaticMethods.Contains(privateMethod)) { staticMethods.Add(privateMethod); } } if (staticMethods.IsEmpty()) { return; } // assign to buckets var statics = CollectionUtil.Subdivide(staticMethods, maxMethodsPerClass); // for each bucket for (var i = 0; i < statics.Count; i++) { var bucket = statics[i]; // new inner class var className = inner.ClassName + "util" + i; var properties = new CodegenClassProperties(); var methods = new CodegenClassMethods(); methods.PrivateMethods.AddAll(bucket); foreach (CodegenMethodWGraph privateMethod in bucket) { privateMethod.WithStatic(); } var utilClass = new CodegenInnerClass( className, null, EmptyList <CodegenTypedParam> .Instance, methods, properties); clazz.AddInnerClass(utilClass); // repoint foreach (var privateMethod in bucket) { privateMethod.Originator.AssignedProviderClassName = className; } // remove private methods from inner class inner.Methods.PrivateMethods.RemoveAll(bucket); } }
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); }