public StmtClassForgableAIFactoryProviderBase( string className, CodegenNamespaceScope namespaceScope) { _className = className; _namespaceScope = namespaceScope; }
public static void MakeSubstitutionSetter( CodegenNamespaceScope packageScope, CodegenBlock enclosingBlock, CodegenClassScope classScope) { var assignLambda = new CodegenExpressionLambda(enclosingBlock) .WithParam<StatementAIFactoryAssignments>("assignments"); //var assignMethod = CodegenMethod // .MakeParentNode(typeof(void), typeof(StmtClassForgableStmtFields), classScope) // .AddParam(typeof(StatementAIFactoryAssignments), "assignments"); //assignerSetterClass.AddMethod("Assign", assignMethod); assignLambda.Block.ExprDotMethod(Ref("statementFields"), "Assign", Ref("assignments")); //assignMethod.Block.StaticMethod(packageScope.FieldsClassName, "Assign", Ref("assignments")); var setValueMethod = new CodegenExpressionLambda(enclosingBlock) .WithParam(typeof(int), "index") .WithParam(typeof(object), "value"); //assignerSetterClass.AddMethod("SetValue", setValueMethod); var assignerSetterClass = NewInstance<ProxyFAFQueryMethodAssignerSetter>( assignLambda, setValueMethod); //var assignerSetterClass = NewAnonymousClass(enclosingBlock, typeof(FAFQueryMethodAssignerSetter)); enclosingBlock.ReturnMethodOrBlock(assignerSetterClass); CodegenSubstitutionParamEntry.CodegenSetterBody( classScope, setValueMethod.Block, Ref("statementFields")); }
public Type CompileStandInClass( CodegenClassType classType, string classNameSimple, ModuleCompileTimeServices services) { var namespaceScope = new CodegenNamespaceScope(services.Namespace, null, false); var classScope = new CodegenClassScope(true, namespaceScope, null); var clazz = new CodegenClass( classType, null, classNameSimple, classScope, EmptyList<CodegenTypedParam>.Instance, null, new CodegenClassMethods(), new CodegenClassProperties(), EmptyList<CodegenInnerClass>.Instance); // This is a bit hacky... basically, Esper has to generate a "Type" that can be returned and // included as the "Underlying" type for the JsonEventType. This method is called during the // portion of the sequence where we are attempting to build the forgeables, so the real type // doesnt exist yet. Esper builds the stand-in but expects that the real type will be used // at runtime. In Java, type erasure allows this to happen because there is no real type in // backing arrays and collections. In .NET we need the types to match. // // We are creating a "capsule" class which will act as a placeholder. When we detect that // the type is a capsule type in the JsonEventType, we will attempt to "resolve" and replace // it. var classNameFull = namespaceScope.Namespace + '.' + classNameSimple; var capsuleClass = CapsuleEmitter.CreateCapsule(classNameFull); return capsuleClass.TargetType; }
public StmtClassForgeableBaseNestableEventTypeSerde(string className, CodegenNamespaceScope namespaceScope, BaseNestableEventType eventType, DataInputOutputSerdeForge[] forges) { this.className = className; this.namespaceScope = namespaceScope; this.eventType = eventType; this.forges = forges; }
public StmtClassForgeableAIFactoryProviderCreateClass( string className, CodegenNamespaceScope packageScope, StatementAgentInstanceFactoryCreateClassForge forge) : base(className, packageScope) { this.forge = forge; }
public StmtClassForgeableAIFactoryProviderSelect( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryForge forge) : base(className, namespaceScope) { this._forge = forge; }
public StmtClassForgeableAIFactoryProviderOnTrigger( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryOnTriggerBaseForge forge) : base(className, namespaceScope) { this.forge = forge; }
public IList<StmtClassForgable> MakeForgables( string queryMethodProviderClassName, string classPostfix, CodegenNamespaceScope namespaceScope) { return Collections.SingletonList<StmtClassForgable>( new StmtClassForgableQueryMethodProvider(queryMethodProviderClassName, namespaceScope, this)); }
public StmtClassForgableStmtFields( string className, CodegenNamespaceScope namespaceScope, int numStreams) { _className = className; _namespaceScope = namespaceScope; _numStreams = numStreams; }
public StmtClassForgableQueryMethodProvider( string className, CodegenNamespaceScope namespaceScope, FAFQueryMethodForge forge) { ClassName = className; this._namespaceScope = namespaceScope; this._forge = forge; }
protected override StmtClassForgeable AiFactoryForgable( string className, CodegenNamespaceScope namespaceScope, EventType statementEventType, string objectName) { var forge = new StatementAgentInstanceFactoryCreateClassForge(statementEventType, className); return new StmtClassForgeableAIFactoryProviderCreateClass(className, namespaceScope, forge); }
public StmtClassForgeableAIFactoryProviderCreateIndex( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryCreateIndexForge forge) : base(className, namespaceScope) { _forge = forge; }
public StmtClassForgableAIFactoryProviderCreateExpression( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryCreateExpressionForge forge) : base(className, namespaceScope) { this.forge = forge; }
public StmtClassForgeableAIFactoryProviderCreateNW( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryCreateNWForge forge, string namedWindowName) : base(className, namespaceScope) { _forge = forge; _namedWindowName = namedWindowName; }
public StmtClassForgeableAIFactoryProviderCreateTable( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryCreateTableForge forge, string tableName) : base(className, namespaceScope) { this.forge = forge; this.tableName = tableName; }
public StmtClassForgableAIFactoryProviderCreateVariable( string className, CodegenNamespaceScope namespaceScope, StatementAgentInstanceFactoryCreateVariableForge forge, string variableName) : base(className, namespaceScope) { _forge = forge; _variableName = variableName; }
public static void MakeSubstitutionSetter( CodegenNamespaceScope packageScope, CodegenMethod method, CodegenClassScope classScope) { MakeSubstitutionSetter( packageScope, method.Block, classScope); }
public StmtClassForgableStmtProvider( string statementAIFactoryClassName, string statementProviderClassName, StatementInformationalsCompileTime statementInformationals, CodegenNamespaceScope namespaceScope) { _statementAiFactoryClassName = statementAIFactoryClassName; ClassName = statementProviderClassName; _statementInformationals = statementInformationals; _namespaceScope = namespaceScope; }
public IList<StmtClassForgeable> MakeForgeables( string queryMethodProviderClassName, string classPostfix, CodegenNamespaceScope namespaceScope) { var forgeables = _additionalForgeables .Select(additional => additional.Make(namespaceScope, classPostfix)) .ToList(); forgeables.Add(new StmtClassForgeableQueryMethodProvider(queryMethodProviderClassName, namespaceScope, this)); return forgeables; }
public StmtClassForgeableMultiKey( string className, CodegenNamespaceScope namespaceScope, Type[] types, bool lenientEquals) { _className = className; _namespaceScope = namespaceScope; _types = types; _lenientEquals = lenientEquals; }
public StmtClassForgeableJsonUnderlying( string className, string classNameFull, CodegenNamespaceScope namespaceScope, StmtClassForgeableJsonDesc desc) { this.className = className; this.classNameFull = classNameFull; this.namespaceScope = namespaceScope; this.desc = desc; }
public StmtClassForgableRSPFactoryProvider( string className, ResultSetProcessorDesc spec, CodegenNamespaceScope namespaceScope, StatementRawInfo statementRawInfo) { ClassName = className; _spec = spec; _namespaceScope = namespaceScope; _statementRawInfo = statementRawInfo; }
public StmtClassForgeableMultiKeySerde( string className, CodegenNamespaceScope namespaceScope, Type[] types, string classNameMK, DataInputOutputSerdeForge[] forges) { this.className = className; this.namespaceScope = namespaceScope; this.types = types; this.classNameMK = classNameMK; this.forges = forges; }
public StmtClassForgeableJsonDeserializer( CodegenClassType classType, string className, CodegenNamespaceScope namespaceScope, string underlyingClassName, StmtClassForgeableJsonDesc desc) { _classType = classType; _className = className; _namespaceScope = namespaceScope; _underlyingClassName = underlyingClassName; _desc = desc; }
public StmtClassForgableOPVFactoryProvider( string className, OutputProcessViewFactoryForge spec, CodegenNamespaceScope namespaceScope, int numStreams, StatementRawInfo raw) { ClassName = className; _spec = spec; _namespaceScope = namespaceScope; _numStreams = numStreams; _raw = raw; }
public StmtClassForgeableAIFactoryProviderCreateContext( string className, CodegenNamespaceScope namespaceScope, string contextName, ContextControllerFactoryForge[] forges, EventType eventTypeContextProperties, StatementAgentInstanceFactoryCreateContextForge forge) : base(className, namespaceScope) { this.contextName = contextName; this.forges = forges; this.eventTypeContextProperties = eventTypeContextProperties; this.forge = forge; }
public StmtClassForgeableJsonSerializer( CodegenClassType classType, string className, bool makeWriteMethod, CodegenNamespaceScope namespaceScope, string underlyingClassName, StmtClassForgeableJsonDesc desc) { _classType = classType; _className = className; _makeWriteMethod = makeWriteMethod; _namespaceScope = namespaceScope; _underlyingClassName = underlyingClassName; _desc = desc; }
public static string CompileQuery( FAFQueryMethodForge query, string classPostfix, ModuleCompileTimeServices compileTimeServices, out Assembly assembly) { var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), classPostfix); var packageScope = new CodegenNamespaceScope( compileTimeServices.Namespace, statementFieldsClassName, compileTimeServices.IsInstrumented()); var queryMethodProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(FAFQueryMethodProvider), classPostfix); var forgeablesQueryMethod = query.MakeForgeables(queryMethodProviderClassName, classPostfix, packageScope); IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(forgeablesQueryMethod); forgeables.Add(new StmtClassForgeableStmtFields(statementFieldsClassName, packageScope, 0)); // forge with statement-fields last var classes = new List<CodegenClass>(forgeables.Count); foreach (var forgeable in forgeables) { var clazz = forgeable.Forge(true, true); classes.Add(clazz); } // assign the assembly (required for completeness) assembly = null; // compile with statement-field first classes = classes .OrderBy(c => c.ClassType.GetSortCode()) .ToList(); var container = compileTimeServices.Container; var compiler = container .RoslynCompiler() .WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode) .WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory) .WithCodegenClasses(classes); assembly = compiler.Compile(); return queryMethodProviderClassName; }
public IList<StmtClassForgable> MakeForgables( string queryMethodProviderClassName, string classPostfix, CodegenNamespaceScope namespaceScope) { IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); //namespaceScopeP forgables.Add( new StmtClassForgableRSPFactoryProvider( _classNameResultSetProcessor, _desc.ResultSetProcessor, namespaceScope, _statementRawInfo)); // generate faf-select forgables.Add(new StmtClassForgableQueryMethodProvider(queryMethodProviderClassName, namespaceScope, this)); return forgables; }
public StmtForgeMethodResult Make( string @namespace, string classPostfix, StatementCompileTimeServices services) { var statementSpec = @base.StatementSpec; var spec = statementSpec.Raw.CreateSchemaDesc; if (services.EventTypeCompileTimeResolver.GetTypeByName(spec.SchemaName) != null) { throw new ExprValidationException( "Event type named '" + spec.SchemaName + "' has already been declared"); } EPLValidationUtil.ValidateTableExists(services.TableCompileTimeResolver, spec.SchemaName); var eventType = HandleCreateSchema(spec, services); var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementFields), classPostfix); var namespaceScope = new CodegenNamespaceScope( @namespace, statementFieldsClassName, services.IsInstrumented); var fieldsForgable = new StmtClassForgableStmtFields(statementFieldsClassName, namespaceScope, 0); var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple( typeof(StatementAIFactoryProvider), classPostfix); var forge = new StatementAgentInstanceFactoryCreateSchemaForge(eventType); var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateSchema( aiFactoryProviderClassName, namespaceScope, forge); var selectSubscriberDescriptor = new SelectSubscriberDescriptor(); var informationals = StatementInformationalsUtil.GetInformationals( @base, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), false, selectSubscriberDescriptor, namespaceScope, services); var statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix); var stmtProvider = new StmtClassForgableStmtProvider( aiFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope); IList<StmtClassForgable> forgables = new List<StmtClassForgable>(); forgables.Add(fieldsForgable); forgables.Add(aiFactoryForgable); forgables.Add(stmtProvider); return new StmtForgeMethodResult( forgables, new EmptyList<FilterSpecCompiled>(), new EmptyList<ScheduleHandleCallbackProvider>(), new EmptyList<NamedWindowConsumerStreamSpec>(), new EmptyList<FilterSpecParamExprNodeForge>()); }