private static void MakeFactory(
OrderByProcessorFactoryForge forge,
CodegenClassScope classScope,
IList<CodegenInnerClass> innerClasses,
string providerClassName)
{
var instantiateMethod = CodegenMethod
.MakeMethod(
typeof(OrderByProcessor),
typeof(OrderByProcessorCompiler),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(AgentInstanceContext), MEMBER_AGENTINSTANCECONTEXT.Ref);
forge.InstantiateCodegen(instantiateMethod, classScope);
var ctorParams = Collections.SingletonList(new CodegenTypedParam(providerClassName, "o"));
var ctor = new CodegenCtor(typeof(OrderByProcessorCompiler), classScope, ctorParams);
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
// --------------------------------------------------------------------------------
// Add statementFields
// --------------------------------------------------------------------------------
var members = new List<CodegenTypedParam> {
new CodegenTypedParam(
classScope.NamespaceScope.FieldsClassName,
null,
"statementFields",
false,
false)
};
ctor.Block.AssignRef(
Ref("this.statementFields"),
Ref("o.statementFields"));
// --------------------------------------------------------------------------------
CodegenStackGenerator.RecursiveBuildStack(instantiateMethod, "Instantiate", methods, properties);
var innerClass = new CodegenInnerClass(
CLASSNAME_ORDERBYPROCESSORFACTORY,
typeof(OrderByProcessorFactory),
ctor,
members,
methods,
properties);
innerClasses.Add(innerClass);
}
private static void MakeResultSetProcessorFactory(
CodegenClassScope classScope,
IList<CodegenInnerClass> innerClasses,
IList<CodegenTypedParam> providerExplicitMembers,
CodegenCtor providerCtor,
string providerClassName)
{
var instantiateMethod = CodegenMethod.MakeMethod(
typeof(ResultSetProcessor),
typeof(StmtClassForgableRSPFactoryProvider),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(OrderByProcessor), NAME_ORDERBYPROCESSOR)
.AddParam(typeof(AggregationService), NAME_AGGREGATIONSVC)
.AddParam(typeof(AgentInstanceContext), NAME_AGENTINSTANCECONTEXT);
instantiateMethod.Block.MethodReturn(
NewInstance(
CLASSNAME_RESULTSETPROCESSOR,
Ref("o"),
REF_ORDERBYPROCESSOR,
REF_AGGREGATIONSVC,
REF_AGENTINSTANCECONTEXT));
var properties = new CodegenClassProperties();
var methods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(instantiateMethod, "Instantiate", methods, properties);
var ctorParams = Collections.SingletonList(new CodegenTypedParam(providerClassName, "o"));
var ctor = new CodegenCtor(
typeof(StmtClassForgableRSPFactoryProvider),
classScope,
ctorParams);
var innerClass = new CodegenInnerClass(
CLASSNAME_RESULTSETPROCESSORFACTORY,
typeof(ResultSetProcessorFactory),
ctor,
Collections.GetEmptyList<CodegenTypedParam>(),
methods,
properties);
innerClasses.Add(innerClass);
providerExplicitMembers.Add(new CodegenTypedParam(typeof(ResultSetProcessorFactory), "rspFactory"));
providerCtor.Block.AssignRef(
MEMBERNAME_RESULTSETPROCESSORFACTORY,
NewInstance(CLASSNAME_RESULTSETPROCESSORFACTORY, Ref("this")));
}
private static void MakeOPVFactory(
CodegenClassScope classScope,
ICollection<CodegenInnerClass> innerClasses,
ICollection<CodegenTypedParam> providerExplicitMembers,
CodegenCtor providerCtor,
string providerClassName)
{
var makeViewMethod = CodegenMethod.MakeMethod(
typeof(OutputProcessView),
typeof(StmtClassForgableOPVFactoryProvider),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(typeof(ResultSetProcessor), NAME_RESULTSETPROCESSOR)
.AddParam(typeof(AgentInstanceContext), NAME_AGENTINSTANCECONTEXT);
makeViewMethod.Block.MethodReturn(
NewInstance(CLASSNAME_OUTPUTPROCESSVIEW, Ref("o"), REF_RESULTSETPROCESSOR, REF_AGENTINSTANCECONTEXT));
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
CodegenStackGenerator.RecursiveBuildStack(makeViewMethod, "MakeView", methods, properties);
var ctorParams = Collections.SingletonList(new CodegenTypedParam(providerClassName, "o"));
var ctor = new CodegenCtor(typeof(StmtClassForgableOPVFactoryProvider), classScope, ctorParams);
var innerClass = new CodegenInnerClass(
CLASSNAME_OUTPUTPROCESSVIEWFACTORY,
typeof(OutputProcessViewFactory),
ctor,
Collections.GetEmptyList<CodegenTypedParam>(),
methods,
properties);
innerClasses.Add(innerClass);
providerCtor.Block.AssignRef(
MEMBERNAME_OPVFACTORY,
NewInstance(CLASSNAME_OUTPUTPROCESSVIEWFACTORY, Ref("this")))
.AssignRef(
MEMBERNAME_STATEMENTRESULTSVC,
ExprDotName(
EPStatementInitServicesConstants.REF,
EPStatementInitServicesConstants.STATEMENTRESULTSERVICE));
}
private static void MakeService(
OrderByProcessorFactoryForge forge,
CodegenClassScope classScope,
IList<CodegenInnerClass> innerClasses,
string providerClassName)
{
var namedMethods = new CodegenNamedMethods();
var sortPlainMethod = CodegenMethod.MakeMethod(
typeof(EventBean[]),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(SORTPLAIN_PARAMS);
forge.SortPlainCodegen(sortPlainMethod, classScope, namedMethods);
var sortWGroupKeysMethod = CodegenMethod.MakeMethod(
typeof(EventBean[]),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(SORTWGROUPKEYS_PARAMS);
forge.SortWGroupKeysCodegen(sortWGroupKeysMethod, classScope, namedMethods);
var sortRollupMethod = CodegenMethod.MakeMethod(
typeof(EventBean[]),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(SORTROLLUP_PARAMS);
forge.SortRollupCodegen(sortRollupMethod, classScope, namedMethods);
var getSortKeyMethod = CodegenMethod
.MakeMethod(typeof(object), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(EventBean[]), REF_EPS.Ref)
.AddParam(typeof(bool), ExprForgeCodegenNames.REF_ISNEWDATA.Ref)
.AddParam(
typeof(ExprEvaluatorContext),
REF_EXPREVALCONTEXT.Ref);
forge.GetSortKeyCodegen(getSortKeyMethod, classScope, namedMethods);
var getSortKeyRollupMethod = CodegenMethod
.MakeMethod(typeof(object), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(EventBean[]), REF_EPS.Ref)
.AddParam(typeof(bool), ExprForgeCodegenNames.REF_ISNEWDATA.Ref)
.AddParam(typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref)
.AddParam(
typeof(AggregationGroupByRollupLevel),
REF_ORDERROLLUPLEVEL.Ref);
forge.GetSortKeyRollupCodegen(getSortKeyRollupMethod, classScope, namedMethods);
var sortWOrderKeysMethod = CodegenMethod
.MakeMethod(typeof(EventBean[]), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(typeof(EventBean[]), REF_OUTGOINGEVENTS.Ref)
.AddParam(typeof(object[]), REF_ORDERKEYS.Ref)
.AddParam(typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref);
forge.SortWOrderKeysCodegen(sortWOrderKeysMethod, classScope, namedMethods);
var sortTwoKeysMethod = CodegenMethod.MakeMethod(
typeof(EventBean[]),
forge.GetType(),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(SORTTWOKEYS_PARAMS);
forge.SortTwoKeysCodegen(sortTwoKeysMethod, classScope, namedMethods);
IList<CodegenTypedParam> members = new List<CodegenTypedParam>();
IList<CodegenTypedParam> ctorParams = new List<CodegenTypedParam>();
ctorParams.Add(new CodegenTypedParam(providerClassName, "o"));
var ctor = new CodegenCtor(typeof(OrderByProcessorCompiler), classScope, ctorParams);
// --------------------------------------------------------------------------------
// Add statementFields
// --------------------------------------------------------------------------------
members.Add(
new CodegenTypedParam(
classScope.NamespaceScope.FieldsClassName,
null,
"statementFields",
false,
false));
ctor.Block.AssignRef(
Ref("this.statementFields"),
Ref("o.statementFields"));
// --------------------------------------------------------------------------------
forge.CtorCodegen(ctor, members, classScope);
CodegenClassProperties innerProperties = new CodegenClassProperties();
var innerMethods = new CodegenClassMethods();
CodegenStackGenerator.RecursiveBuildStack(sortPlainMethod, "SortPlain", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(sortWGroupKeysMethod, "SortWGroupKeys", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(sortRollupMethod, "SortRollup", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(getSortKeyMethod, "GetSortKey", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(getSortKeyRollupMethod, "GetSortKeyRollup", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(sortWOrderKeysMethod, "SortWOrderKeys", innerMethods, innerProperties);
CodegenStackGenerator.RecursiveBuildStack(sortTwoKeysMethod, "SortTwoKeys", innerMethods, innerProperties);
foreach (var methodEntry in namedMethods.Methods) {
CodegenStackGenerator.RecursiveBuildStack(methodEntry.Value, methodEntry.Key, innerMethods, innerProperties);
}
var innerClass = new CodegenInnerClass(
CLASSNAME_ORDERBYPROCESSOR,
typeof(OrderByProcessor),
ctor,
members,
innerMethods,
innerProperties);
innerClasses.Add(innerClass);
}
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(StmtClassForgableOPVFactoryProvider), 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<MultiKey<EventBean>>), NAME_NEWDATA)
.AddParam(typeof(ISet<MultiKey<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);
}
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);
}
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);
}
}
public void AddInnerClass(CodegenInnerClass innerClass)
{
AdditionalInnerClasses.Add(innerClass);
}
