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