public static void InitBlockSizeOneEventPlus(
int numParameters,
CodegenBlock block,
CodegenExpression innerValue,
int streamNumLambda,
Type evaluationType)
{
var blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar <EventBean>("item", Cast(typeof(EventBean), ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First")))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(streamNumLambda), Ref("item"))
.AssignArrayElement("props", Constant(0), Constant(0));
if (numParameters > 2)
{
blockSingle.AssignArrayElement("props", Constant(1), Constant(1));
}
block.DebugStack();
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
evaluationType,
innerValue,
EnumValue(typeof(FlexCollection), "Empty"));
blockSingle.BlockReturn(
FlexWrap(StaticMethod(typeof(Collections), "SingletonList", Ref("item"))));
block.DeclareVar <ArrayDeque <EventBean> >("result", NewInstance <ArrayDeque <EventBean> >());
}
public CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(subselect.EvaluationType, GetType(), classScope);
var havingMethod = CodegenLegoMethodExpression.CodegenExpression(subselect.HavingExpr, method, classScope, true);
CodegenExpression having = LocalMethod(
havingMethod,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method));
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
method.Block,
typeof(bool?),
having,
ConstantNull());
if (subselect.SelectClause.Length == 1) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true);
method.Block.MethodReturn(
LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)));
}
else {
method.Block.MethodReturn(LocalMethod(subselect.EvaluateRowCodegen(method, classScope)));
}
return LocalMethod(method);
}
public static CodegenExpression Codegen(
EnumTakeWhileScalarForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumTakeWhileScalarForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var innerValue = forge.InnerExpression.EvaluateCodegen(
typeof(bool?),
methodNode,
scope,
codegenClassScope);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
block.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("evalEvent"), "Properties"));
var blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar<object>(
"item",
ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First"))
.AssignArrayElement("props", Constant(0), Ref("item"));
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
forge.InnerExpression.EvaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexValue(Ref("item")));
block.DeclareVar<ArrayDeque<object>>("result", NewInstance(typeof(ArrayDeque<object>)));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenBreakIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
innerValue);
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumTakeWhileEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var returnType = typeof(FlexCollection);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
returnType,
typeof(EnumTakeWhileEventsForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var innerValue = forge.InnerExpression.EvaluateCodegen(
typeof(bool?),
methodNode,
scope,
codegenClassScope);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
var blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar<EventBean>("item",
ExprDotMethod(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "EventBeanCollection"), "First"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("item"));
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
forge.InnerExpression.EvaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexEvent(Ref("item")));
block.DeclareVar<ArrayDeque<EventBean>>("result", NewInstance(typeof(ArrayDeque<EventBean>)));
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenBreakIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
innerValue);
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static void InitBlockSizeOneScalar(
int numParameters,
CodegenBlock block,
CodegenExpression innerValue,
Type evaluationType)
{
var blockSingle = block.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar <object>("item", ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First"))
.AssignArrayElement("props", Constant(0), Ref("item"));
if (numParameters >= 2)
{
blockSingle.AssignArrayElement("props", Constant(1), Constant(0));
}
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
evaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexValue(Ref("item")));
block.DeclareVar <ArrayDeque <object> >("result", NewInstance <ArrayDeque <object> >());
}
public override void InitBlock(
CodegenBlock block,
CodegenMethod methodNode,
ExprForgeCodegenSymbol scope,
CodegenClassScope codegenClassScope)
{
innerValue = InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope);
var blockSingle = block.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar <EventBean>("item", Cast(typeof(EventBean), ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First")))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("item"));
block.DebugStack();
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
InnerExpression.EvaluationType,
innerValue,
EnumValue(typeof(FlexCollection), "Empty"));
blockSingle.BlockReturn(
FlexWrap(StaticMethod(typeof(Collections), "SingletonList", Ref("item"))));
block
.DeclareVar <ArrayDeque <EventBean> >("result", NewInstance <ArrayDeque <EventBean> >())
.DeclareVar <EventBean[]>("all", StaticMethod(typeof(EnumTakeWhileHelper), "TakeWhileLastEventBeanToArray", EnumForgeCodegenNames.REF_ENUMCOLL));
var forEach = block.ForLoop(
typeof(int),
"i",
Op(ArrayLength(Ref("all")), "-", Constant(1)),
Relational(Ref("i"), GE, Constant(0)),
DecrementRef("i"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), ArrayAtIndex(Ref("all"), Ref("i")));
CodegenLegoBooleanExpression.CodegenBreakIfNotNullAndNotPass(forEach, InnerExpression.EvaluationType, innerValue);
forEach.Expression(ExprDotMethod(Ref("result"), "AddFirst", ArrayAtIndex(Ref("all"), Ref("i"))));
}
