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