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);
}
public void CtorCodegen(
CodegenCtor ctor,
IList<CodegenTypedParam> members,
CodegenClassScope classScope)
{
}
public CodegenClass Forge(bool includeDebugSymbols)
{
var debugInformationProvider = new Supplier<string>(
() => {
var writer = new StringWriter();
writer.Write("FAF query");
return writer.ToString();
});
try {
IList<CodegenInnerClass> innerClasses = new List<CodegenInnerClass>();
// build ctor
IList<CodegenTypedParam> ctorParms = new List<CodegenTypedParam>();
ctorParms.Add(
new CodegenTypedParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref,
false));
ctorParms.Add(
new CodegenTypedParam(
_namespaceScope.FieldsClassName,
null,
"statementFields",
true,
false));
var providerCtor = new CodegenCtor(GetType(), ClassName, includeDebugSymbols, ctorParms);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
// add query method member
IList<CodegenTypedParam> providerExplicitMembers = new List<CodegenTypedParam>(2);
providerExplicitMembers.Add(new CodegenTypedParam(typeof(FAFQueryMethod), MEMBERNAME_QUERYMETHOD));
var symbols = new SAIFFInitializeSymbol();
var makeMethod = providerCtor.MakeChildWithScope(typeof(FAFQueryMethod), GetType(), symbols, classScope)
.AddParam(typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref);
providerCtor.Block
.ExprDotMethod(Ref("statementFields"), "Init", EPStatementInitServicesConstants.REF)
.AssignRef(MEMBERNAME_QUERYMETHOD, LocalMethod(makeMethod, EPStatementInitServicesConstants.REF));
_forge.MakeMethod(makeMethod, symbols, classScope);
// make provider methods
var propQueryMethod = CodegenProperty.MakePropertyNode(
typeof(FAFQueryMethod),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propQueryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_QUERYMETHOD));
// add get-informational methods
var propQueryInformationals = CodegenProperty.MakePropertyNode(
typeof(FAFQueryInformationals),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
var queryInformationals = FAFQueryInformationals.From(
_namespaceScope.SubstitutionParamsByNumber,
_namespaceScope.SubstitutionParamsByName);
queryInformationals.Make(
propQueryInformationals.GetterBlock,
classScope);
// add get-statement-fields method
var propSubstitutionFieldSetter = CodegenProperty.MakePropertyNode(
typeof(FAFQueryMethodAssignerSetter),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
StmtClassForgableStmtFields.MakeSubstitutionSetter(
_namespaceScope,
propSubstitutionFieldSetter.GetterBlock,
classScope);
// make provider methods
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
CodegenStackGenerator.RecursiveBuildStack(providerCtor, "ctor", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(propQueryMethod, "QueryMethod", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(propQueryInformationals, "QueryInformationals", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(propSubstitutionFieldSetter, "SubstitutionFieldSetter", methods, properties);
// render and compile
return new CodegenClass(
typeof(FAFQueryMethodProvider),
_namespaceScope.Namespace,
ClassName,
classScope,
providerExplicitMembers,
providerCtor,
methods,
properties,
innerClasses);
}
catch (EPException) {
throw;
}
catch (Exception e) {
throw new EPException(
"Fatal exception during code-generation for " +
debugInformationProvider.Invoke() +
" : " +
e.Message,
e);
}
}
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);
}
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);
}
public abstract void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope);
public CodegenBlock(CodegenCtor parentCtor)
: this(parentCtor, null, null)
{
}
public CodegenClass Forge(
bool includeDebugSymbols,
bool fireAndForget)
{
IList <CodegenTypedParam> @params = new List <CodegenTypedParam>();
for (var i = 0; i < _types.Length; i++)
{
@params.Add(new CodegenTypedParam(_types[i].GetBoxedType(), "k" + i));
}
var ctor = new CodegenCtor(typeof(StmtClassForgeableMultiKey), ClassName, includeDebugSymbols, @params);
var properties = new CodegenClassProperties();
var methods = new CodegenClassMethods();
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, _className);
var hashMethod = CodegenMethod
.MakeParentNode(typeof(int), typeof(StmtClassForgeableMultiKey), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
MakeHashMethod(_types.Length, hashMethod);
CodegenStackGenerator.RecursiveBuildStack(hashMethod, "GetHashCode", methods, properties);
var equalsMethod = CodegenMethod
.MakeParentNode(typeof(bool), typeof(StmtClassForgeableMultiKey), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride()
.AddParam(typeof(object), "o");
MakeEqualsMethod(_types.Length, equalsMethod);
CodegenStackGenerator.RecursiveBuildStack(equalsMethod, "Equals", methods, properties);
var numKeysProperty = CodegenProperty
.MakePropertyNode(typeof(int), typeof(StmtClassForgeableMultiKey), CodegenSymbolProviderEmpty.INSTANCE, classScope);
numKeysProperty.GetterBlock.BlockReturn(Constant(_types.Length));
CodegenStackGenerator.RecursiveBuildStack(numKeysProperty, "NumKeys", methods, properties);
var getKeyMethod = CodegenMethod
.MakeParentNode(typeof(object), typeof(StmtClassForgeableMultiKey), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(int), "num");
MakeGetKeyMethod(_types.Length, getKeyMethod);
CodegenStackGenerator.RecursiveBuildStack(getKeyMethod, "GetKey", methods, properties);
var toStringMethod = CodegenMethod
.MakeParentNode(typeof(string), typeof(StmtClassForgeableMultiKey), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
MakeToStringMethod(toStringMethod);
CodegenStackGenerator.RecursiveBuildStack(toStringMethod, "ToString", methods, properties);
return(new CodegenClass(
CodegenClassType.KEYPROVISIONING,
typeof(MultiKey),
_className,
classScope,
EmptyList <CodegenTypedParam> .Instance,
ctor,
methods,
properties,
EmptyList <CodegenInnerClass> .Instance));
}
private static CodegenInnerClass MakeSelectExprProcessor(
string className,
string classNameParent,
CodegenClassScope classScope,
SelectExprProcessorForge forge)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var selectEnv = new SelectExprProcessorCodegenSymbol();
CodegenSymbolProvider symbolProvider = new ProxyCodegenSymbolProvider(
symbols => {
exprSymbol.Provide(symbols);
selectEnv.Provide(symbols);
});
var members = new List <CodegenTypedParam>(2);
members.Add(new CodegenTypedParam(classScope.NamespaceScope.FieldsClassName, NAME_STATEMENT_FIELDS));
members.Add(new CodegenTypedParam(typeof(EventBeanTypedEventFactory), MEMBER_EVENTBEANFACTORY.Ref));
var ctorParams = new List <CodegenTypedParam>(2);
ctorParams.Add(new CodegenTypedParam(classNameParent, "o"));
ctorParams.Add(new CodegenTypedParam(typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref, false));
var ctor = new CodegenCtor(typeof(StmtClassForgeableRSPFactoryProvider), classScope, ctorParams);
ctor.Block.AssignRef(MEMBER_STATEMENT_FIELDS, ExprDotName(Ref("o"), NAME_STATEMENT_FIELDS));
ctor.Block.AssignRef(MEMBER_EVENTBEANFACTORY, ExprDotName(EPStatementInitServicesConstants.REF, "EventBeanTypedEventFactory"));
var processMethod = CodegenMethod
.MakeMethod(typeof(EventBean), typeof(StmtClassForgeableRSPFactoryProvider), symbolProvider, classScope)
.AddParam(typeof(EventBean[]), ExprForgeCodegenNames.NAME_EPS)
.AddParam(typeof(bool), ExprForgeCodegenNames.NAME_ISNEWDATA)
.AddParam(typeof(bool), SelectExprProcessorCodegenSymbol.NAME_ISSYNTHESIZE)
.AddParam(typeof(ExprEvaluatorContext), ExprForgeCodegenNames.NAME_EXPREVALCONTEXT);
processMethod.Block.Apply(
InstrumentationCode.Instblock(
classScope,
"qSelectClause",
REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_ISSYNTHESIZE,
REF_EXPREVALCONTEXT));
var performMethod = forge.ProcessCodegen(
Member("o." + MEMBERNAME_RESULTEVENTTYPE),
MEMBER_EVENTBEANFACTORY,
processMethod,
selectEnv,
exprSymbol,
classScope);
exprSymbol.DerivedSymbolsCodegen(processMethod, processMethod.Block, classScope);
processMethod.Block
.DeclareVar <EventBean>("@out", LocalMethod(performMethod))
.Apply(
InstrumentationCode.Instblock(
classScope,
"aSelectClause",
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
Ref("@out"),
ConstantNull()))
.MethodReturn(Ref("@out"));
var allProperties = new CodegenClassProperties();
var allMethods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(processMethod, "Process", allMethods, allProperties);
return(new CodegenInnerClass(
className,
typeof(SelectExprProcessor),
ctor,
members,
allMethods,
allProperties));
}
private static void MakeOPV(
CodegenClassScope classScope,
IList<CodegenInnerClass> innerClasses,
IList<CodegenTypedParam> factoryExplicitMembers,
CodegenCtor factoryCtor,
string classNameParent,
OutputProcessViewFactoryForge forge,
int numStreams)
{
IList<CodegenTypedParam> ctorParams = new List<CodegenTypedParam>();
ctorParams.Add(new CodegenTypedParam(classNameParent, "o"));
ctorParams.Add(new CodegenTypedParam(typeof(ResultSetProcessor), NAME_RESULTSETPROCESSOR));
ctorParams.Add(new CodegenTypedParam(typeof(AgentInstanceContext), NAME_AGENTINSTANCECONTEXT));
// make ctor code
var serviceCtor = new CodegenCtor(typeof(StmtClassForgeableOPVFactoryProvider), classScope, ctorParams);
// Get-Result-Type Method
var eventTypeGetter = CodegenProperty
.MakePropertyNode(typeof(EventType), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
eventTypeGetter.GetterBlock.BlockReturn(ExprDotName(Ref(NAME_RESULTSETPROCESSOR), "ResultEventType"));
// Process-View-Result Method
var updateMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride()
.AddParam(typeof(EventBean[]), NAME_NEWDATA)
.AddParam(typeof(EventBean[]), NAME_OLDDATA);
if (numStreams == 1) {
forge.UpdateCodegen(updateMethod, classScope);
}
else {
updateMethod.Block.MethodThrowUnsupported();
}
// Process-Join-Result Method
var processMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride()
.AddParam(typeof(ISet<MultiKeyArrayOfKeys<EventBean>>), NAME_NEWDATA)
.AddParam(typeof(ISet<MultiKeyArrayOfKeys<EventBean>>), NAME_OLDDATA)
.AddParam(
typeof(ExprEvaluatorContext),
"notApplicable");
if (numStreams == 1) {
processMethod.Block.MethodThrowUnsupported();
}
else {
forge.ProcessCodegen(processMethod, classScope);
}
// Stop-Method (generates last as other methods may allocate members)
var enumeratorMethod = CodegenMethod
.MakeMethod(
typeof(IEnumerator<EventBean>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.WithOverride();
forge.EnumeratorCodegen(enumeratorMethod, classScope);
// NumChangesetRows (always zero for generated code)
var numChangesetRowsProp = CodegenProperty
.MakePropertyNode(typeof(int), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
numChangesetRowsProp.GetterBlock.BlockReturn(Constant(0));
// OptionalOutputCondition (always null for generated code)
var optionalOutputConditionProp = CodegenProperty
.MakePropertyNode(typeof(OutputCondition), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
optionalOutputConditionProp.GetterBlock.BlockReturn(ConstantNull());
// Stop-Method (no action for generated code)
CodegenMethod stopMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride()
.AddParam(typeof(AgentInstanceStopServices), "svc");
// Terminate-Method (no action for generated code)
CodegenMethod terminatedMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithOverride();
var innerProperties = new CodegenClassProperties();
var innerMethods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(
eventTypeGetter,
"EventType",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
updateMethod,
"Update",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processMethod,
"Process",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
enumeratorMethod,
"GetEnumerator",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
numChangesetRowsProp,
"NumChangesetRows",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
optionalOutputConditionProp,
"OptionalOutputCondition",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
stopMethod,
"Stop",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
terminatedMethod,
"Terminated",
innerMethods,
innerProperties);
var innerClass = new CodegenInnerClass(
CLASSNAME_OUTPUTPROCESSVIEW,
typeof(OutputProcessView),
serviceCtor,
Collections.GetEmptyList<CodegenTypedParam>(),
innerMethods,
innerProperties);
innerClasses.Add(innerClass);
}
public CodegenClass Forge(
bool includeDebugSymbols,
bool fireAndForget)
{
Supplier<string> debugInformationProvider = () => {
var writer = new StringWriter();
_raw.AppendCodeDebugInfo(writer);
writer.Write(" output-processor ");
writer.Write(_spec.GetType().FullName);
return writer.ToString();
};
try {
IList<CodegenInnerClass> innerClasses = new List<CodegenInnerClass>();
// build ctor
IList<CodegenTypedParam> ctorParms = new List<CodegenTypedParam>();
ctorParms.Add(
new CodegenTypedParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref,
false));
ctorParms.Add(
new CodegenTypedParam(
_namespaceScope.FieldsClassName,
null,
"statementFields",
true,
false));
var providerCtor = new CodegenCtor(
typeof(StmtClassForgeableOPVFactoryProvider),
ClassName,
includeDebugSymbols,
ctorParms);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
var providerExplicitMembers = new List<CodegenTypedParam>();
providerExplicitMembers.Add(
new CodegenTypedParam(typeof(StatementResultService), MEMBERNAME_STATEMENTRESULTSVC));
providerExplicitMembers.Add(
new CodegenTypedParam(typeof(OutputProcessViewFactory), MEMBERNAME_OPVFACTORY));
if (_spec.IsCodeGenerated) {
// make factory and view both, assign to member
MakeOPVFactory(classScope, innerClasses, providerExplicitMembers, providerCtor, ClassName);
MakeOPV(
classScope,
innerClasses,
Collections.GetEmptyList<CodegenTypedParam>(),
providerCtor,
ClassName,
_spec,
_numStreams);
}
else {
// build factory from existing classes
var symbols = new SAIFFInitializeSymbol();
var init = providerCtor
.MakeChildWithScope(typeof(OutputProcessViewFactory), GetType(), symbols, classScope)
.AddParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref);
_spec.ProvideCodegen(init, symbols, classScope);
providerCtor.Block.AssignRef(
MEMBERNAME_OPVFACTORY,
LocalMethod(init, EPStatementInitServicesConstants.REF));
}
// make get-factory method
var factoryMethodGetter = CodegenProperty.MakePropertyNode(
typeof(OutputProcessViewFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
factoryMethodGetter.GetterBlock.BlockReturn(Ref(MEMBERNAME_OPVFACTORY));
var properties = new CodegenClassProperties();
var methods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(
providerCtor,
"ctor",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
factoryMethodGetter,
"OutputProcessViewFactory",
methods,
properties);
// render and compile
return new CodegenClass(
CodegenClassType.OUTPUTPROCESSVIEWFACTORYPROVIDER,
typeof(OutputProcessViewFactoryProvider),
ClassName,
classScope,
providerExplicitMembers,
providerCtor,
methods,
properties,
innerClasses);
}
catch (Exception t) {
throw new EPException(
"Fatal exception during code-generation for " +
debugInformationProvider.Invoke() +
" : " +
t.Message,
t);
}
}
public CodegenClass Forge(
bool includeDebugSymbols,
bool fireAndForget)
{
// write code to create an implementation of StatementResource
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
// members
IList<CodegenTypedParam> members = new List<CodegenTypedParam>();
members.Add(new CodegenTypedParam(_namespaceScope.FieldsClassName, MEMBERNAME_STATEMENT_FIELDS));
members.Add(new CodegenTypedParam(typeof(StatementInformationalsRuntime), MEMBERNAME_INFORMATION));
members.Add(new CodegenTypedParam(typeof(StatementAIFactoryProvider), MEMBERNAME_FACTORY_PROVIDER).WithFinal(false));
// ctor
var ctor = new CodegenCtor(GetType(), ClassName, includeDebugSymbols, Collections.GetEmptyList<CodegenTypedParam>());
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
ctor.Block.AssignMember(MEMBERNAME_INFORMATION, _statementInformationals.Make(ctor, classScope));
var initializeMethod = MakeInitialize(classScope);
var statementAIFactoryProviderProp = MakeGetStatementAIFactoryProvider(classScope);
var statementInformationalsProp = CodegenProperty.MakePropertyNode(
typeof(StatementInformationalsRuntime),
typeof(StmtClassForgeableStmtProvider),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
statementInformationalsProp
.GetterBlock.BlockReturn(Ref(MEMBERNAME_INFORMATION));
CodegenStackGenerator.RecursiveBuildStack(
statementInformationalsProp,
"Informationals",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeMethod,
"Initialize",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
statementAIFactoryProviderProp,
"StatementAIFactoryProvider",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
ctor,
"ctor",
methods,
properties);
return new CodegenClass(
CodegenClassType.STATEMENTPROVIDER,
typeof(StatementProvider),
ClassName,
classScope,
members,
ctor,
methods,
properties,
EmptyList<CodegenInnerClass>.Instance);
}
public CodegenClass Forge(
bool includeDebugSymbols,
bool fireAndForget)
{
// REGION: Constructor
var ctorParams = new List<CodegenTypedParam>() {
new CodegenTypedParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref,
false)
};
if (_namespaceScope.FieldsClassName != null) {
ctorParams.Add(
new CodegenTypedParam(
_namespaceScope.FieldsClassName,
MEMBERNAME_STATEMENT_FIELDS));
}
var ctor = new CodegenCtor(GetType(), _className, includeDebugSymbols, ctorParams);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
if (_namespaceScope.FieldsClassName != null) {
ctor.Block.ExprDotMethod(
Ref(MEMBERNAME_STATEMENT_FIELDS),
"Init",
EPStatementInitServicesConstants.REF);
}
ctor.Block.AssignRef(
MEMBERNAME_STATEMENTAIFACTORY,
LocalMethod(
CodegenConstructorInit(ctor, classScope),
SAIFFInitializeSymbol.REF_STMTINITSVC));
// REGION: Members
var members = new List<CodegenTypedParam>();
members.Add(new CodegenTypedParam(typeof(Guid), MEMBERNAME_ID));
members.Add(new CodegenTypedParam(TypeOfFactory(), MEMBERNAME_STATEMENTAIFACTORY));
// REGION: Properties
var properties = new CodegenClassProperties();
var factoryProp = CodegenProperty.MakePropertyNode(
typeof(StatementAgentInstanceFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
factoryProp.GetterBlock.BlockReturn(Ref(MEMBERNAME_STATEMENTAIFACTORY));
// REGION: Methods
var methods = new CodegenClassMethods();
var assignMethod = CodegenMethod
.MakeMethod(typeof(void), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(StatementAIFactoryAssignments), "assignments");
if (_namespaceScope.FieldsClassName != null) {
//assignMethod.Block..Debug("Assign", Ref("assignments"))
assignMethod.Block.ExprDotMethod(Ref(MEMBERNAME_STATEMENT_FIELDS), "Assign", Ref("assignments"));
//assignMethod.Block.StaticMethod(_namespaceScope.FieldsClassNameOptional, "Assign", Ref("assignments"));
}
var unassignMethod = CodegenMethod
.MakeMethod(typeof(void), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope);
if (_namespaceScope.FieldsClassName != null) {
unassignMethod.Block.ExprDotMethod(Ref(MEMBERNAME_STATEMENT_FIELDS), "Unassign");
//unassignMethod.Block.StaticMethod(_namespaceScope.FieldsClassNameOptional, "Unassign");
}
var setValueMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(StmtClassForgeableStmtFields), classScope)
.AddParam(typeof(int), "index")
.AddParam(typeof(object), "value");
CodegenSubstitutionParamEntry.CodegenSetterBody(
classScope, setValueMethod.Block, Ref(MEMBERNAME_STATEMENT_FIELDS));
// Assignment, not sure why this is being done... TBD - Burn this
CodegenStackGenerator.RecursiveBuildStack(factoryProp, "Factory", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(assignMethod, "Assign", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(unassignMethod, "Unassign", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(setValueMethod, "SetValue", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(ctor, "Ctor", methods, properties);
return new CodegenClass(
CodegenClassType.STATEMENTAIFACTORYPROVIDER,
typeof(StatementAIFactoryProvider),
ClassName,
classScope,
members,
ctor,
methods,
properties,
EmptyList<CodegenInnerClass>.Instance);
}
public void InstanceCodegen(
CodegenInstanceAux instance,
CodegenClassScope classScope,
CodegenCtor factoryCtor,
IList<CodegenTypedParam> factoryMembers)
{
instance.Properties.AddProperty(
typeof(AggregationService),
"AggregationService",
GetType(),
classScope,
node => node.GetterBlock.BlockReturn(MEMBER_AGGREGATIONSVC));
instance.Methods.AddMethod(
typeof(ExprEvaluatorContext),
"GetAgentInstanceContext",
EmptyList<CodegenNamedParam>.Instance,
GetType(),
classScope,
node => node.Block.ReturnMethodOrBlock(MEMBER_AGENTINSTANCECONTEXT));
instance.Properties.AddProperty(
typeof(bool),
"IsSelectRStream",
typeof(ResultSetProcessorRowForAll),
classScope,
node => node.GetterBlock.BlockReturn(Constant(IsSelectRStream)));
var rollupDesc = classScope.AddDefaultFieldUnshared(
true,
typeof(AggregationGroupByRollupDesc),
GroupByRollupDesc.Codegen(classScope.NamespaceScope.InitMethod, classScope));
instance.Properties.AddProperty(
typeof(AggregationGroupByRollupDesc),
"GroupByRollupDesc",
typeof(ResultSetProcessorRowPerGroupRollup),
classScope,
node => node.GetterBlock.BlockReturn(rollupDesc));
GenerateGroupKeySingle = ResultSetProcessorGroupedUtil.GenerateGroupKeySingleCodegen(GroupKeyNodeExpressions, MultiKeyClassRef, classScope, instance);
ResultSetProcessorRowPerGroupRollupImpl.RemovedAggregationGroupKeyCodegen(classScope, instance);
ResultSetProcessorRowPerGroupRollupImpl.GenerateOutputBatchedMapUnsortedCodegen(this, instance, classScope);
ResultSetProcessorRowPerGroupRollupImpl.GenerateOutputBatchedCodegen(this, instance, classScope);
// generate having clauses
var havingForges = PerLevelForges.OptionalHavingForges;
if (havingForges != null) {
factoryMembers.Add(
new CodegenTypedParam(typeof(HavingClauseEvaluator[]), NAME_HAVINGEVALUATOR_ARRAYNONMEMBER));
factoryCtor.Block.AssignRef(
NAME_HAVINGEVALUATOR_ARRAYNONMEMBER,
NewArrayByLength(typeof(HavingClauseEvaluator), Constant(havingForges.Length)));
for (var i = 0; i < havingForges.Length; i++) {
var evaluateHaving = new CodegenExpressionLambda(factoryCtor.Block)
.WithParams(PARAMS)
.WithBody(block => block.BlockReturn(
CodegenLegoMethodExpression.CodegenBooleanExpressionReturnTrueFalse(
havingForges[i],
classScope,
factoryCtor,
REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_EXPREVALCONTEXT)));
var impl = NewInstance<ProxyHavingClauseEvaluator>(evaluateHaving);
//var evaluateHaving = CodegenMethod.MakeMethod(typeof(bool), GetType(), classScope)
// .AddParam(PARAMS);
//impl.AddMethod("EvaluateHaving", evaluateHaving);
factoryCtor.Block.AssignArrayElement(NAME_HAVINGEVALUATOR_ARRAYNONMEMBER, Constant(i), impl);
}
}
}
private static void MakeResultSetProcessor(
CodegenClassScope classScope,
IList<CodegenInnerClass> innerClasses,
IList<CodegenTypedParam> factoryExplicitMembers,
CodegenCtor factoryCtor,
string classNameParent,
ResultSetProcessorDesc spec)
{
IList<CodegenTypedParam> ctorParams = new List<CodegenTypedParam>();
ctorParams.Add(new CodegenTypedParam(classNameParent, "o"));
ctorParams.Add(new CodegenTypedParam(typeof(OrderByProcessor), "orderByProcessor"));
ctorParams.Add(new CodegenTypedParam(typeof(AggregationService), "aggregationService"));
ctorParams.Add(new CodegenTypedParam(typeof(AgentInstanceContext), "agentInstanceContext"));
// make ctor code
var serviceCtor = new CodegenCtor(
typeof(StmtClassForgableRSPFactoryProvider),
classScope,
ctorParams);
// Get-Result-Type Method
var forge = spec.ResultSetProcessorFactoryForge;
var resultEventTypeGetter = CodegenProperty.MakePropertyNode(
typeof(EventType),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
resultEventTypeGetter.GetterBlock.BlockReturn(Ref("o." + MEMBERNAME_RESULTEVENTTYPE));
// Instance members and methods
var instance = new CodegenInstanceAux(serviceCtor);
// --------------------------------------------------------------------------------
// Add statementFields
// --------------------------------------------------------------------------------
instance.Members.Add(
new CodegenTypedParam(
classScope.NamespaceScope.FieldsClassName,
null,
"statementFields",
false,
false));
serviceCtor.Block.AssignRef(
Ref("this.statementFields"),
Ref("o.statementFields"));
// --------------------------------------------------------------------------------
forge.InstanceCodegen(instance, classScope, factoryCtor, factoryExplicitMembers);
// Process-View-Result Method
var processViewResultMethod = CodegenMethod.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(EventBean[]), NAME_NEWDATA)
.AddParam(typeof(EventBean[]), NAME_OLDDATA)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin) {
GenerateInstrumentedProcessView(forge, classScope, processViewResultMethod, instance);
}
else {
processViewResultMethod.Block.MethodThrowUnsupported();
}
// Process-Join-Result Method
var processJoinResultMethod = CodegenMethod
.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_NEWDATA)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_OLDDATA)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
processJoinResultMethod.Block.DebugStack();
if (!spec.IsJoin) {
processJoinResultMethod.Block.MethodThrowUnsupported();
}
else {
GenerateInstrumentedProcessJoin(forge, classScope, processJoinResultMethod, instance);
}
// Clear-Method
var clearMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope);
forge.ClearMethodCodegen(classScope, clearMethod);
// Get-Enumerator-View
var getEnumeratorMethodView = CodegenMethod
.MakeMethod(
typeof(IEnumerator<EventBean>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(Viewable), NAME_VIEWABLE);
if (!spec.IsJoin) {
forge.GetEnumeratorViewCodegen(classScope, getEnumeratorMethodView, instance);
}
else {
getEnumeratorMethodView.Block.MethodThrowUnsupported();
}
// Get-Enumerator-Join
var getEnumeratorMethodJoin = CodegenMethod
.MakeMethod(
typeof(IEnumerator<EventBean>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_JOINSET);
if (!spec.IsJoin) {
getEnumeratorMethodJoin.Block.MethodThrowUnsupported();
}
else {
forge.GetEnumeratorJoinCodegen(classScope, getEnumeratorMethodJoin, instance);
}
// Process-output-rate-buffered-view
var processOutputLimitedViewMethod = CodegenMethod
.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(IList<UniformPair<EventBean[]>>), NAME_VIEWEVENTSLIST)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin && spec.HasOutputLimit && !spec.HasOutputLimitSnapshot) {
forge.ProcessOutputLimitedViewCodegen(classScope, processOutputLimitedViewMethod, instance);
}
else {
processOutputLimitedViewMethod.Block.MethodThrowUnsupported();
}
// Process-output-rate-buffered-join
var processOutputLimitedJoinMethod = CodegenMethod
.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(IList<UniformPair<ISet<MultiKey<EventBean>>>>), NAME_JOINEVENTSSET)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin || !spec.HasOutputLimit || spec.HasOutputLimitSnapshot) {
processOutputLimitedJoinMethod.Block.MethodThrowUnsupported();
}
else {
forge.ProcessOutputLimitedJoinCodegen(classScope, processOutputLimitedJoinMethod, instance);
}
// Set-Agent-Instance is supported for fire-and-forget queries only
var setAgentInstanceContextMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(AgentInstanceContext), "value");
setAgentInstanceContextMethod.Block.AssignRef(NAME_AGENTINSTANCECONTEXT, Ref("value"));
// Apply-view
var applyViewResultMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(EventBean[]), NAME_NEWDATA)
.AddParam(typeof(EventBean[]), NAME_OLDDATA);
if (!spec.IsJoin && spec.HasOutputLimit && spec.HasOutputLimitSnapshot) {
forge.ApplyViewResultCodegen(classScope, applyViewResultMethod, instance);
}
else {
applyViewResultMethod.Block.MethodThrowUnsupported();
}
// Apply-join
var applyJoinResultMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_NEWDATA)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_OLDDATA);
if (!spec.IsJoin || !spec.HasOutputLimit || !spec.HasOutputLimitSnapshot) {
applyJoinResultMethod.Block.MethodThrowUnsupported();
}
else {
forge.ApplyJoinResultCodegen(classScope, applyJoinResultMethod, instance);
}
// Process-output-unbuffered-view
var processOutputLimitedLastAllNonBufferedViewMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(EventBean[]), NAME_NEWDATA)
.AddParam(typeof(EventBean[]), NAME_OLDDATA)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin && spec.HasOutputLimit && spec.OutputConditionType == POLICY_LASTALL_UNORDERED) {
forge.ProcessOutputLimitedLastAllNonBufferedViewCodegen(
classScope,
processOutputLimitedLastAllNonBufferedViewMethod,
instance);
}
else {
processOutputLimitedLastAllNonBufferedViewMethod.Block.MethodThrowUnsupported();
}
// Process-output-unbuffered-join
var processOutputLimitedLastAllNonBufferedJoinMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_NEWDATA)
.AddParam(typeof(ISet<MultiKey<EventBean>>), NAME_OLDDATA)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin || !spec.HasOutputLimit || spec.OutputConditionType != POLICY_LASTALL_UNORDERED) {
processOutputLimitedLastAllNonBufferedJoinMethod.Block.MethodThrowUnsupported();
}
else {
forge.ProcessOutputLimitedLastAllNonBufferedJoinCodegen(
classScope,
processOutputLimitedLastAllNonBufferedJoinMethod,
instance);
}
// Continue-output-unbuffered-view
var continueOutputLimitedLastAllNonBufferedViewMethod = CodegenMethod
.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin && spec.HasOutputLimit && spec.OutputConditionType == POLICY_LASTALL_UNORDERED) {
forge.ContinueOutputLimitedLastAllNonBufferedViewCodegen(
classScope,
continueOutputLimitedLastAllNonBufferedViewMethod,
instance);
}
else {
continueOutputLimitedLastAllNonBufferedViewMethod.Block.MethodThrowUnsupported();
}
// Continue-output-unbuffered-join
var continueOutputLimitedLastAllNonBufferedJoinMethod = CodegenMethod
.MakeMethod(
typeof(UniformPair<EventBean[]>),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(bool), NAME_ISSYNTHESIZE);
if (!spec.IsJoin || !spec.HasOutputLimit || spec.OutputConditionType != POLICY_LASTALL_UNORDERED) {
continueOutputLimitedLastAllNonBufferedJoinMethod.Block.MethodThrowUnsupported();
}
else {
forge.ContinueOutputLimitedLastAllNonBufferedJoinCodegen(
classScope,
continueOutputLimitedLastAllNonBufferedJoinMethod,
instance);
}
// Accept-Helper-Visitor
var acceptHelperVisitorMethod = CodegenMethod
.MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(ResultSetProcessorOutputHelperVisitor), NAME_RESULTSETVISITOR);
forge.AcceptHelperVisitorCodegen(classScope, acceptHelperVisitorMethod, instance);
// Stop-Method (generates last as other methods may allocate members)
var stopMethod = CodegenMethod.MakeMethod(
typeof(void),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
forge.StopMethodCodegen(classScope, stopMethod, instance);
var innerProperties = new CodegenClassProperties();
var innerMethods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(
resultEventTypeGetter,
"ResultEventType",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processViewResultMethod,
"ProcessViewResult",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processJoinResultMethod,
"ProcessJoinResult",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
getEnumeratorMethodView,
"GetEnumerator",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
getEnumeratorMethodJoin,
"GetEnumerator",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
clearMethod,
"Clear",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
stopMethod,
"Stop",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processOutputLimitedJoinMethod,
"ProcessOutputLimitedJoin",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processOutputLimitedViewMethod,
"ProcessOutputLimitedView",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
setAgentInstanceContextMethod,
"SetAgentInstanceContext",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
applyViewResultMethod,
"ApplyViewResult",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
applyJoinResultMethod,
"ApplyJoinResult",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processOutputLimitedLastAllNonBufferedViewMethod,
"ProcessOutputLimitedLastAllNonBufferedView",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
processOutputLimitedLastAllNonBufferedJoinMethod,
"ProcessOutputLimitedLastAllNonBufferedJoin",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
continueOutputLimitedLastAllNonBufferedViewMethod,
"ContinueOutputLimitedLastAllNonBufferedView",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
continueOutputLimitedLastAllNonBufferedJoinMethod,
"ContinueOutputLimitedLastAllNonBufferedJoin",
innerMethods,
innerProperties);
CodegenStackGenerator.RecursiveBuildStack(
acceptHelperVisitorMethod,
"AcceptHelperVisitor",
innerMethods,
innerProperties);
foreach (var propertyEntry in instance.Properties.Properties)
{
CodegenStackGenerator.RecursiveBuildStack(
propertyEntry.Value,
propertyEntry.Key,
innerMethods,
innerProperties);
}
foreach (var methodEntry in instance.Methods.Methods) {
CodegenStackGenerator.RecursiveBuildStack(
methodEntry.Value,
methodEntry.Key,
innerMethods,
innerProperties);
}
var innerClass = new CodegenInnerClass(
CLASSNAME_RESULTSETPROCESSOR,
forge.InterfaceClass,
serviceCtor,
instance.Members,
innerMethods,
innerProperties);
innerClasses.Add(innerClass);
}
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);
}
public CodegenClass Forge(bool includeDebugSymbols)
{
Supplier<string> debugInformationProvider = () => {
var writer = new StringWriter();
_statementRawInfo.AppendCodeDebugInfo(writer);
writer.Write(" result-set-processor ");
writer.Write(_spec.ResultSetProcessorFactoryForge.GetType().FullName);
return writer.ToString();
};
try {
IList<CodegenInnerClass> innerClasses = new List<CodegenInnerClass>();
// build ctor
IList<CodegenTypedParam> ctorParms = new List<CodegenTypedParam>();
ctorParms.Add(
new CodegenTypedParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref,
false));
ctorParms.Add(
new CodegenTypedParam(
_namespaceScope.FieldsClassName,
null,
MEMBERNAME_STATEMENT_FIELDS,
true,
false));
var providerCtor = new CodegenCtor(
typeof(StmtClassForgableRSPFactoryProvider),
ClassName,
includeDebugSymbols,
ctorParms);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
var providerExplicitMembers = new List<CodegenTypedParam>(2);
// add event type
providerExplicitMembers.Add(new CodegenTypedParam(typeof(EventType), MEMBERNAME_RESULTEVENTTYPE));
providerCtor.Block.AssignRef(
MEMBERNAME_RESULTEVENTTYPE,
EventTypeUtility.ResolveTypeCodegen(_spec.ResultEventType, EPStatementInitServicesConstants.REF));
MakeResultSetProcessorFactory(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName);
MakeResultSetProcessor(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
_spec);
OrderByProcessorCompiler.MakeOrderByProcessors(
_spec.OrderByProcessorFactoryForge,
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
MEMBERNAME_ORDERBYFACTORY);
providerExplicitMembers.Add(
new CodegenTypedParam(typeof(AggregationServiceFactory), MEMBERNAME_AGGREGATIONSVCFACTORY));
var aggregationClassNames = new AggregationClassNames();
var aggResult = AggregationServiceFactoryCompiler.MakeInnerClassesAndInit(
_spec.IsJoin,
_spec.AggregationServiceForgeDesc.AggregationServiceFactoryForge,
providerCtor,
classScope,
ClassName,
aggregationClassNames);
providerCtor.Block.AssignRef(
MEMBERNAME_AGGREGATIONSVCFACTORY,
LocalMethod(aggResult.InitMethod, EPStatementInitServicesConstants.REF));
innerClasses.AddAll(aggResult.InnerClasses);
MakeSelectExprProcessors(
classScope,
innerClasses,
providerExplicitMembers,
providerCtor,
ClassName,
_spec.IsRollup,
_spec.SelectExprProcessorForges);
// make provider methods
var propResultSetProcessorFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(ResultSetProcessorFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultSetProcessorFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_RESULTSETPROCESSORFACTORY));
var propAggregationServiceFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(AggregationServiceFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propAggregationServiceFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_AGGREGATIONSVCFACTORY));
var propOrderByProcessorFactoryMethod = CodegenProperty.MakePropertyNode(
typeof(OrderByProcessorFactory),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propOrderByProcessorFactoryMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_ORDERBYFACTORY));
var propResultSetProcessorTypeMethod = CodegenProperty.MakePropertyNode(
typeof(ResultSetProcessorType),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultSetProcessorTypeMethod
.GetterBlock
.BlockReturn(EnumValue(typeof(ResultSetProcessorType), _spec.ResultSetProcessorType.GetName()));
var propResultEventTypeMethod = CodegenProperty.MakePropertyNode(
typeof(EventType),
GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
propResultEventTypeMethod
.GetterBlock
.BlockReturn(Ref(MEMBERNAME_RESULTEVENTTYPE));
var properties = new CodegenClassProperties();
var methods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(providerCtor, "ctor", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultSetProcessorFactoryMethod,
"ResultSetProcessorFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propAggregationServiceFactoryMethod,
"AggregationServiceFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propOrderByProcessorFactoryMethod,
"OrderByProcessorFactory",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultSetProcessorTypeMethod,
"ResultSetProcessorType",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
propResultEventTypeMethod,
"ResultEventType",
methods,
properties);
// render and compile
return new CodegenClass(
typeof(ResultSetProcessorFactoryProvider),
_namespaceScope.Namespace,
ClassName,
classScope,
providerExplicitMembers,
providerCtor,
methods,
properties,
innerClasses);
}
catch (Exception t) {
throw new EPException(
"Fatal exception during code-generation for " +
debugInformationProvider.Invoke() +
" : " +
t.Message,
t);
}
}
public CodegenClass Forge(
bool includeDebugSymbols,
bool fireAndForget)
{
// members
IList<CodegenTypedParam> members = new List<CodegenTypedParam>();
// Add a reference to "self"
members.Add(new CodegenTypedParam(_className, null, "statementFields", false, false));
GenerateNamedMembers(members);
// numbered members
foreach (var entry in _namespaceScope.FieldsUnshared) {
var field = entry.Key;
members.Add(
new CodegenTypedParam(field.Type, field.Name)
.WithStatic(false)
.WithFinal(false));
}
// substitution-parameter members
GenerateSubstitutionParamMembers(members);
var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName);
// ctor
var ctor = new CodegenCtor(GetType(), ClassName, includeDebugSymbols, Collections.GetEmptyList<CodegenTypedParam>());
ctor.Block.AssignRef(Ref("statementFields"), Ref("this"));
// init method
var initMethod = _namespaceScope.InitMethod;
foreach (var entry in _namespaceScope.FieldsUnshared) {
initMethod.Block.AssignRef(entry.Key.Name, entry.Value);
}
// assignment methods
var assignMethod = CodegenMethod
.MakeMethod(typeof(void), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(StatementAIFactoryAssignments), "assignments")
.WithStatic(false);
var unassignMethod = CodegenMethod
.MakeMethod(typeof(void), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.WithStatic(false);
GenerateAssignAndUnassign(_numStreams, assignMethod, unassignMethod, _namespaceScope.FieldsNamed);
// build methods
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
CodegenStackGenerator.RecursiveBuildStack(initMethod, "Init", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(assignMethod, "Assign", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(unassignMethod, "Unassign", methods, properties);
return new CodegenClass(
CodegenClassType.STATEMENTFIELDS,
typeof(StatementFields),
ClassName,
classScope,
members,
ctor,
methods,
properties,
Collections.GetEmptyList<CodegenInnerClass>());
}
