public abstract void InlineInitializeOnTriggerBase(
CodegenExpressionRef saiff,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope);
public void RowReadMethodCodegen(
CodegenMethod method,
int level)
{
}
public override void ClearCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(state, "Clear");
}
public void AcceptCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(REF_AGGVISITOR, "VisitAggregations", Constant(1), REF_ROW);
}
public void AcceptGroupDetailCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
// not implemented
}
public static CodegenExpression Codegen(
PointIntersectsRectangleForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(bool?),
typeof(SettingsApplicationDotMethodRectangeIntersectsRectangle.RectangleIntersectsRectangleEvaluator
),
codegenClassScope);
CodegenBlock block = methodNode.Block;
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"px",
forge.pxEval,
methodNode,
exprSymbol,
codegenClassScope);
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"py",
forge.pyEval,
methodNode,
exprSymbol,
codegenClassScope);
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"x",
forge.xEval,
methodNode,
exprSymbol,
codegenClassScope);
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"y",
forge.yEval,
methodNode,
exprSymbol,
codegenClassScope);
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"width",
forge.widthEval,
methodNode,
exprSymbol,
codegenClassScope);
CodegenLegoCast.AsDoubleNullReturnNull(
block,
"height",
forge.heightEval,
methodNode,
exprSymbol,
codegenClassScope);
block.MethodReturn(
CodegenExpressionBuilder.StaticMethod(
typeof(BoundingBox),
"ContainsPoint",
CodegenExpressionBuilder.Ref("x"),
CodegenExpressionBuilder.Ref("y"),
CodegenExpressionBuilder.Ref("width"),
CodegenExpressionBuilder.Ref("height"),
CodegenExpressionBuilder.Ref("px"),
CodegenExpressionBuilder.Ref("py")));
return(CodegenExpressionBuilder.LocalMethod(methodNode));
}
public void SetRemovedCallbackCodegen(CodegenMethod method)
{
// no code
}
public static CodegenLocalMethodBuilder LocalMethodBuild(CodegenMethod methodNode)
{
return new CodegenLocalMethodBuilder(methodNode);
}
public static CodegenExpressionLocalMethod LocalMethod(
CodegenMethod methodNode,
params CodegenExpression[] parameters)
{
return new CodegenExpressionLocalMethod(methodNode, parameters);
}
public static CodegenExpression MakePatternDeltaLambda(
ExprNode parameter,
MatchedEventConvertorForge convertor,
TimeAbacus timeAbacus,
CodegenMethod method,
CodegenClassScope classScope)
{
var computeDelta = new CodegenExpressionLambda(method.Block)
.WithParam<MatchedEventMap>("beginState")
.WithParam<PatternAgentInstanceContext>("context");
var compute = NewInstance<PatternDeltaCompute>(computeDelta);
//var compute = NewAnonymousClass(method.Block, typeof(PatternDeltaCompute));
//var computeDelta = CodegenMethod.MakeMethod(typeof(long), typeof(PatternDeltaComputeUtil), classScope)
// .AddParam(
// CodegenNamedParam.From(
// typeof(MatchedEventMap),
// "beginState",
// typeof(PatternAgentInstanceContext),
// "context"));
//compute.AddMethod("ComputeDelta", computeDelta);
if (parameter is ExprTimePeriod) {
var timePeriod = (ExprTimePeriod) parameter;
var time = ExprDotName(Ref("context"), "Time");
if (timePeriod.IsConstantResult) {
var delta = classScope.AddDefaultFieldUnshared<TimePeriodCompute>(
true,
timePeriod.TimePeriodComputeForge.MakeEvaluator(
classScope.NamespaceScope.InitMethod,
classScope));
computeDelta.Block
.ReturnMethodOrBlock(
ExprDotMethod(
delta,
"DeltaAdd",
time,
ConstantNull(),
ConstantTrue(),
ExprDotMethod(Ref("context"), "GetAgentInstanceContext")));
}
else {
var delta = classScope.AddDefaultFieldUnshared<TimePeriodCompute>(
true,
timePeriod.TimePeriodComputeForge.MakeEvaluator(
classScope.NamespaceScope.InitMethod,
classScope));
computeDelta.Block
.DeclareVar<EventBean[]>(
"events",
LocalMethod(
convertor.Make(method, classScope),
//convertor.Make(computeDelta, classScope),
Ref("beginState")))
.ReturnMethodOrBlock(
ExprDotMethod(
delta,
"DeltaAdd",
time,
Ref("events"),
ConstantTrue(),
ExprDotMethod(Ref("context"), "GetAgentInstanceContext")));
}
}
else {
var eval = CodegenLegoMethodExpression.CodegenExpression(parameter.Forge, method, classScope, true);
CodegenExpression events;
if (parameter.Forge.ForgeConstantType.IsConstant) {
events = ConstantNull();
}
else {
events = LocalMethod(
convertor.Make(method, classScope),
//convertor.Make(computeDelta, classScope),
Ref("beginState"));
}
computeDelta.Block
.DeclareVar<EventBean[]>("events", events)
.DeclareVar(
parameter.Forge.EvaluationType.GetBoxedType(),
"result",
LocalMethod(
eval,
Ref("events"),
ConstantTrue(),
ExprDotMethod(Ref("context"), "GetAgentInstanceContext")));
if (parameter.Forge.EvaluationType.CanBeNull()) {
computeDelta.Block
.IfRefNull("result")
.BlockThrow(
NewInstance<EPException>(Constant("Null value returned for guard expression")));
}
computeDelta.Block.ReturnMethodOrBlock(
timeAbacus.DeltaForSecondsDoubleCodegen(Ref("result"), classScope));
}
return compute;
}
public CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var serializers = classScope.AddDefaultFieldUnshared(
true,
typeof(Serializer[]),
StaticMethod(
typeof(SerializerFactory),
"GetSerializers",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(nodes))));
CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope)
.AddParam(typeof(EventBean), "eventBean");
method.Block
.DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean")));
// method to return object-array from expressions
ExprForgeCodegenSymbol exprSymbol = new ExprForgeCodegenSymbol(true, null);
CodegenMethod exprMethod = method
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
CodegenExpression[] expressions = new CodegenExpression[nodes.Length];
for (int i = 0; i < nodes.Length; i++) {
expressions[i] = nodes[i]
.Forge.EvaluateCodegen(
nodes[i].Forge.EvaluationType,
exprMethod,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope);
if (nodes.Length == 1) {
exprMethod.Block.MethodReturn(expressions[0]);
}
else {
exprMethod.Block.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(nodes.Length)));
for (int i = 0; i < nodes.Length; i++) {
CodegenExpression result = expressions[i];
exprMethod.Block.AssignArrayElement("values", Constant(i), result);
}
exprMethod.Block.MethodReturn(Ref("values"));
}
method.Block
.DeclareVar<object>(
"values",
LocalMethod(exprMethod, Ref("events"), ConstantTrue(), ConstantNull()))
.MethodReturn(
StaticMethod(
typeof(ContextControllerHashedGetterCRC32SerializedForge),
"SerializeAndCRC32Hash",
Ref("values"),
Constant(granularity),
serializers));
return LocalMethod(method, beanExpression);
}
private static void RecursiveAdd(
CodegenMethod methodNode,
IDictionary<string, Type> currentSymbols,
CodegenClassMethods classMethods,
CodegenClassProperties classProperties,
bool isStatic)
{
ISet<string> namesPassed = GetNamesPassed(methodNode);
methodNode.DeepParameters = namesPassed;
IList<CodegenNamedParam> paramset = new List<CodegenNamedParam>(
namesPassed.Count + methodNode.LocalParams.Count);
// add local params
foreach (var named in methodNode.LocalParams) {
paramset.Add(named);
}
// add pass-thru for those methods that do not have their own scope
if (methodNode.OptionalSymbolProvider == null) {
foreach (var nameX in namesPassed) {
var symbolType = currentSymbols.Get(nameX);
if (symbolType == null) {
throw new IllegalStateException(
"Failed to find named parameter '" +
nameX +
"' for method from " +
methodNode.AdditionalDebugInfo);
}
paramset.Add(new CodegenNamedParam(symbolType, nameX));
}
}
else {
currentSymbols = new Dictionary<string, Type>();
methodNode.OptionalSymbolProvider.Provide(currentSymbols);
}
var name = "M" + classMethods.PrivateMethods.Count;
var footprint = new CodegenMethodFootprint(
methodNode.ReturnType,
methodNode.ReturnTypeName,
paramset,
methodNode.AdditionalDebugInfo);
var method = new CodegenMethodWGraph(
name,
footprint,
methodNode.Block,
false,
methodNode.IsOverride,
isStatic);
methodNode.AssignedMethod = method;
classMethods.PrivateMethods.Add(method);
foreach (var child in methodNode.Children) {
RecursiveAdd(
child,
currentSymbols,
classMethods,
classProperties,
isStatic);
}
}
private static ISet<string> GetNamesPassed(CodegenMethod node)
{
var names = new SortedSet<string>();
RecursiveGetNamesPassed(node, names);
return names;
}
public abstract void ForEachBlock(
CodegenBlock block,
CodegenMethod methodNode,
ExprForgeCodegenSymbol scope,
CodegenClassScope codegenClassScope);
protected override void ClearWODistinct(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.Apply(GetClear());
}
public void ClearCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.AssignRef(state, ExprDotMethod(spec, "MakeAggState"));
}
public CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope)
.AddParam(typeof(EventBean), "eventBean");
method.Block.DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean")));
// method to evaluate expressions and compute hash
ExprForgeCodegenSymbol exprSymbol = new ExprForgeCodegenSymbol(true, true);
CodegenMethod exprMethod = method
.MakeChildWithScope(
reflectionMethod.ReturnType,
typeof(CodegenLegoMethodExpression),
exprSymbol,
classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
// generate args
StaticMethodCodegenArgDesc[] args = AllArgumentExpressions(
nodes,
reflectionMethod,
exprMethod,
exprSymbol,
classScope);
AppendArgExpressions(args, exprMethod.Block);
// try block
CodegenBlock tryBlock = exprMethod.Block.TryCatch();
CodegenExpression invoke = CodegenInvokeExpression(null, reflectionMethod, args, classScope);
tryBlock.BlockReturn(invoke);
// exception handling
AppendCatch(
tryBlock,
reflectionMethod,
statementName,
reflectionMethod.DeclaringType.CleanName(),
true,
args);
exprMethod.Block.MethodReturn(Constant(0));
method.Block.DeclareVar(
reflectionMethod.ReturnType,
"result",
LocalMethod(exprMethod, Ref("events"), ConstantTrue(), ConstantNull()));
if (reflectionMethod.ReturnType.CanBeNull()) {
method.Block.IfRefNull("result").BlockReturn(Constant(0));
}
method.Block.DeclareVar<int>(
"value",
SimpleNumberCoercerFactory.GetCoercer(reflectionMethod.ReturnType, typeof(int?))
.CoerceCodegen(Ref("result"), reflectionMethod.ReturnType))
.IfCondition(Relational(Ref("value"), CodegenExpressionRelational.CodegenRelational.GE, Constant(0)))
.BlockReturn(Op(Ref("value"), "%", Constant(granularity)))
.MethodReturn(Op(Op(Ref("value"), "%", Constant(granularity)), "*", Constant(-1)));
return LocalMethod(method, beanExpression);
}
public void ClearCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.MethodThrowUnsupported();
}
public void StopMethodCodegen(
AggregationServiceFactoryForgeWMethodGen forge,
CodegenMethod method)
{
// no code
}
private static CodegenExpression MakeAnnotation(
Attribute annotation,
CodegenMethod parent,
CodegenClassScope codegenClassScope)
{
if (annotation == null) {
return ConstantNull();
}
if (annotation is NameAttribute name) {
return NewInstance<AnnotationName>(
Constant(name.Value));
}
if (annotation is PriorityAttribute priority) {
return NewInstance<AnnotationPriority>(
Constant(priority.Value));
}
if (annotation is TagAttribute tag) {
return NewInstance<AnnotationTag>(
Constant(tag.Name),
Constant(tag.Value));
}
if (annotation is DropAttribute) {
return NewInstance<AnnotationDrop>();
}
if (annotation is DescriptionAttribute description) {
return NewInstance<AnnotationDescription>(
Constant(description.Value));
}
if (annotation is HintAttribute hint) {
return NewInstance<AnnotationHint>(
Constant(hint.Value),
Constant(hint.Applies),
Constant(hint.Model));
}
if (annotation is NoLockAttribute) {
return NewInstance<AnnotationNoLock>();
}
if (annotation is AuditAttribute audit) {
return NewInstance<AnnotationAudit>(Constant(audit.Value));
}
if (annotation is EventRepresentationAttribute anno) {
return NewInstance<AnnotationEventRepresentation>(
EnumValue(
anno.Value.GetType(),
anno.Value.GetName()));
}
if (annotation is IterableUnboundAttribute) {
return NewInstance<AnnotationIterableUnbound>();
}
if (annotation is HookAttribute hook) {
return NewInstance<AnnotationHook>(
EnumValue(typeof(HookType), hook.HookType.GetName()),
Constant(hook.Hook));
}
if (annotation is AvroSchemaFieldAttribute field) {
return NewInstance<AvroSchemaFieldHook>(
Constant(field.Name),
Constant(field.Schema));
}
if (annotation is PrivateAttribute) {
return NewInstance<AnnotationPrivate>();
}
if (annotation is ProtectedAttribute) {
return NewInstance<AnnotationProtected>();
}
if (annotation is PublicAttribute) {
return NewInstance<AnnotationPublic>();
}
if (annotation is BusEventTypeAttribute) {
return NewInstance<AnnotationBusEventType>();
}
if (annotation is JsonSchemaAttribute jsonSchema) {
return NewInstance<AnnotationJsonSchema>(Constant(jsonSchema.Dynamic), Constant(jsonSchema.ClassName));
}
if (annotation is JsonSchemaFieldAttribute jsonSchemaField) {
return NewInstance<AnnotationJsonSchemaField>(Constant(jsonSchemaField.Name), Constant(jsonSchemaField.Adapter));
}
if (annotation is XMLSchemaAttribute xmlSchema) {
return AnnotationXMLSchema.ToExpression(xmlSchema, parent, codegenClassScope);
}
if (annotation is XMLSchemaNamespacePrefixAttribute schemaNamespacePrefix) {
return AnnotationXMLSchemaNamespacePrefix.ToExpression(schemaNamespacePrefix, parent, codegenClassScope);
}
if (annotation is XMLSchemaFieldAttribute xmlSchemaField) {
return AnnotationXMLSchemaField.ToExpression(xmlSchemaField, parent, codegenClassScope);
}
if (annotation.GetType().Namespace == RootNamespace) {
throw new IllegalStateException(
"Unrecognized annotation residing in the '" +
RootNamespace +
" namespace having type" +
annotation.GetType().Name);
}
// application-provided annotation
if (annotation is CustomAttribute) {
return ((CustomAttribute) annotation).MakeCodegenExpression(
parent,
codegenClassScope);
}
if (annotation is IProxyTargetAccessor proxyTargetAccessor) {
var interceptor = (EPLAnnotationInvocationHandler) proxyTargetAccessor.GetInterceptors()[0];
var methodNode = parent.MakeChild(typeof(Attribute), typeof(AnnotationUtil), codegenClassScope);
methodNode.Block.DeclareVar(
interceptor.AnnotationClass,
"annotation",
NewInstance(interceptor.AnnotationClass));
//var annotationType = CodegenMethod.MakeMethod(
// typeof(Type), typeof(AnnotationUtil), codegenClassScope);
//clazz.AddMethod("annotationType", annotationType);
//annotationType.Block.MethodReturn(Clazz(interceptor.AnnotationClass));
foreach (var property in interceptor.AnnotationClass.GetProperties())
{
if (!property.CanWrite) {
continue;
}
CodegenExpression valueExpression;
var value = interceptor.Attributes.Get(property.Name);
if (value == null)
{
valueExpression = ConstantNull();
}
else if (property.PropertyType == typeof(Type))
{
valueExpression = Clazz((Type) value);
}
else if (property.PropertyType.IsArray && property.PropertyType.GetElementType().IsAttribute())
{
valueExpression = LocalMethod(
MakeAnnotations(
property.PropertyType, (Attribute[]) value, methodNode, codegenClassScope));
}
else if (!property.PropertyType.IsAttribute())
{
valueExpression = Constant(value);
}
else
{
valueExpression = FlexCast(
property.PropertyType,
MakeAnnotation((Attribute) value, methodNode, codegenClassScope));
}
methodNode.Block.SetProperty(
Ref("annotation"), property.Name, valueExpression);
}
methodNode.Block.MethodReturn(Ref("annotation"));
return LocalMethod(methodNode);
}
throw new IllegalStateException(
"Unrecognized annotation having type " + annotation.GetType().FullName);
}
public void ClearResultsCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(REF_ROW, "Clear");
}
protected abstract void InlineInitializeOnTriggerSpecific(
CodegenExpressionRef saiff,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope);
public void GetGroupKeyCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.MethodReturn(ConstantNull());
}
public void ClearMethodCodegen(
CodegenClassScope classScope,
CodegenMethod method)
{
ResultSetProcessorRowForAllImpl.ClearCodegen(method);
}
public void RowWriteMethodCodegen(
CodegenMethod method,
int level)
{
}
protected override void ClearWODistinct(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.AssignRef(currentMinMax, ConstantNull());
}
public override void GetValueCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.MethodReturn(StaticMethod(typeof(AggregatorAvedev), "ComputeAvedev", valueSet, sum));
}
public override void GetValueCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.MethodReturn(currentMinMax);
}
public override void InitBlock(CodegenBlock block, CodegenMethod methodNode, ExprForgeCodegenSymbol scope, CodegenClassScope codegenClassScope)
{
block.DeclareVar <int>("rowcount", Constant(0));
}
public void GetValueCodegen(
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.MethodReturn(ExprDotMethod(builder, "ToString"));
}
