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