public static CodegenExpression Codegen(
EnumWhereEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumWhereEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumValue(typeof(FlexCollection), "Empty"));
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.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
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(
EnumCountOfSelectorScalarForge 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(int), typeof(EnumCountOfSelectorScalarForgeEval), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar<int>("count", Constant(0))
.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 forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(Ref("props"), Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.Increment("count");
block.MethodReturn(Ref("count"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumFirstOfPredicateEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(EventBean),
typeof(EnumFirstOfPredicateEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.BlockReturn(Ref("next"));
block.MethodReturn(ConstantNull());
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumWhereScalarIndexForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var evalTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.evalEventType, EPStatementInitServicesConstants.REF)));
var indexTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.indexEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumWhereScalarIndexForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
block
.DeclareVar<ArrayDeque<object>>("result", NewInstance(typeof(ArrayDeque<object>)))
.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), evalTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.streamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("evalProps", ExprDotName(Ref("evalEvent"), "Properties"))
.DeclareVar<ObjectArrayEventBean>(
"indexEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), indexTypeMember))
.AssignArrayElement(
EnumForgeCodegenNames.REF_EPS,
Constant(forge.streamNumLambda + 1),
Ref("indexEvent"))
.DeclareVar<object[]>("indexProps", ExprDotName(Ref("indexEvent"), "Properties"))
.DeclareVar<int>("count", Constant(-1));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.Increment("count")
.AssignArrayElement("evalProps", Constant(0), Ref("next"))
.AssignArrayElement("indexProps", Constant(0), Ref("count"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.innerExpression.EvaluationType,
forge.innerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool?), this.GetType(), classScope);
var left = symbols.GetAddLeftResult(method);
method.Block.DeclareVar<bool>("hasNullRow", ConstantFalse());
var @foreach = method.Block.ForEach(typeof(EventBean), "theEvent", symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(NAME_EPS, Constant(0), Ref("theEvent"));
if (filterEval != null) {
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
filterEval.EvaluationType,
filterEval.EvaluateCodegen(typeof(bool?), method, symbols, classScope));
}
@foreach.IfRefNullReturnNull(left);
Type valueRightType;
if (selectEval != null) {
valueRightType = Boxing.GetBoxedType(selectEval.EvaluationType);
@foreach.DeclareVar(
valueRightType,
"valueRight",
selectEval.EvaluateCodegen(valueRightType, method, symbols, classScope));
}
else {
valueRightType = subselect.RawEventType.UnderlyingType;
@foreach.DeclareVar(
valueRightType,
"valueRight",
Cast(valueRightType, ExprDotUnderlying(ArrayAtIndex(symbols.GetAddEPS(method), Constant(0)))));
}
var ifRight = @foreach.IfCondition(NotEqualsNull(Ref("valueRight")));
{
if (coercer == null) {
ifRight.IfCondition(ExprDotMethod(left, "Equals", Ref("valueRight")))
.BlockReturn(Constant(!isNotIn));
}
else {
ifRight.DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType))
.DeclareVar<object>("right", coercer.CoerceCodegen(Ref("valueRight"), valueRightType))
.DeclareVar<bool>("eq", ExprDotMethod(Ref("left"), "Equals", Ref("right")))
.IfCondition(Ref("eq"))
.BlockReturn(Constant(!isNotIn));
}
}
ifRight.IfElse().AssignRef("hasNullRow", ConstantTrue());
}
method.Block
.IfCondition(Ref("hasNullRow"))
.BlockReturn(ConstantNull())
.MethodReturn(Constant(isNotIn));
return LocalMethod(method);
}
public override void ForEachBlock(
CodegenBlock block,
CodegenMethod methodNode,
ExprForgeCodegenSymbol scope,
CodegenClassScope codegenClassScope)
{
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
block,
InnerExpression.EvaluationType,
InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
block.BlockReturn(Ref("next"));
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, classScope, this.GetType());
CodegenMethod method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
method.Block.DeclareVar<EventBean>("filtered", ConstantNull());
CodegenBlock @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
CodegenMethod filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, method, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
@foreach.IfCondition(NotEqualsNull(Ref("filtered")))
.BlockReturn(ConstantNull())
.AssignRef("filtered", Ref("@event"));
}
method.Block.IfRefNullReturnNull("filtered")
.MethodReturn(
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("filtered"),
symbols.GetAddEPS(method),
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
return LocalMethod(method);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(typeof(EventBean), typeof(EnumLastOfEvent), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar <EventBean>("result", ConstantNull());
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
InnerExpression.EvaluationType,
InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.AssignRef("result", Ref("next"));
block.MethodReturn(Ref("result"));
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
if (subselect.FilterExpr == null) {
method.Block
.IfCondition(
Relational(
ExprDotName(symbols.GetAddMatchingEvents(method), "Count"),
CodegenExpressionRelational.CodegenRelational.GT,
Constant(1)))
.BlockReturn(ConstantNull());
if (subselect.SelectClause == null) {
method.Block.MethodReturn(
Cast(
subselect.EvaluationType,
StaticMethod(
typeof(EventBeanUtility),
"GetNonemptyFirstEventUnderlying",
symbols.GetAddMatchingEvents(method))));
return LocalMethod(method);
}
else {
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols)
.AssignArrayElement(
REF_EVENTS_SHIFTED,
Constant(0),
StaticMethod(
typeof(EventBeanUtility),
"GetNonemptyFirstEvent",
symbols.GetAddMatchingEvents(method)));
}
}
else {
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
method.Block.DeclareVar<EventBean>("filtered", ConstantNull());
var @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
var filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, method, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
@foreach.IfCondition(NotEqualsNull(Ref("filtered")))
.BlockReturn(ConstantNull())
.AssignRef("filtered", Ref("@event"));
}
if (subselect.SelectClause == null) {
method.Block.IfRefNullReturnNull("filtered")
.MethodReturn(Cast(subselect.EvaluationType, ExprDotUnderlying(Ref("filtered"))));
return LocalMethod(method);
}
method.Block.IfRefNullReturnNull("filtered")
.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("filtered"));
}
var selectClause = GetSelectClauseExpr(method, symbols, classScope);
method.Block.MethodReturn(selectClause);
return LocalMethod(method);
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool?), GetType(), classScope);
method.Block
.DeclareVar<bool>("hasRows", ConstantFalse())
.DeclareVar<bool>("hasNullRow", ConstantFalse());
var @foreach = method.Block.ForEach(
typeof(EventBean),
"subselectEvent",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(NAME_EPS, Constant(0), Ref("subselectEvent"));
if (filterOrHavingEval != null) {
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
filterOrHavingEval.EvaluationType,
filterOrHavingEval.EvaluateCodegen(typeof(bool?), method, symbols, classScope));
}
@foreach.AssignRef("hasRows", ConstantTrue());
Type valueRightType;
if (selectEval != null) {
valueRightType = selectEval.EvaluationType.GetBoxedType();
@foreach.DeclareVar(
valueRightType,
"valueRight",
selectEval.EvaluateCodegen(valueRightType, method, symbols, classScope));
}
else {
valueRightType = typeof(object);
@foreach.DeclareVar(
valueRightType,
"valueRight",
ExprDotUnderlying(ArrayAtIndex(symbols.GetAddEPS(method), Constant(0))));
}
@foreach.IfRefNull("valueRight")
.AssignRef("hasNullRow", ConstantTrue())
.IfElse()
.IfCondition(NotEqualsNull(symbols.GetAddLeftResult(method)))
.IfCondition(
Not(
computer.Codegen(
symbols.GetAddLeftResult(method),
symbols.LeftResultType,
Ref("valueRight"),
valueRightType)))
.BlockReturn(ConstantFalse());
}
method.Block
.IfCondition(Not(Ref("hasRows")))
.BlockReturn(ConstantTrue())
.IfCondition(EqualsNull(symbols.GetAddLeftResult(method)))
.BlockReturn(ConstantNull())
.IfCondition(Ref("hasNullRow"))
.BlockReturn(ConstantNull())
.MethodReturn(ConstantTrue());
return LocalMethod(method);
}
