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