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 CodegenEvaluatorWCoerce( ExprForge forge, Type optCoercionType, CodegenMethod method, Type generator, CodegenClassScope classScope) { var evaluate = new CodegenExpressionLambda(method.Block) .WithParams(PARAMS); var evaluator = NewInstance<ProxyExprEvaluator>(evaluate); //var evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator)); //var evaluate = CodegenMethod.MakeParentNode(typeof(object), generator, classScope) // .AddParam(PARAMS); //evaluator.AddMethod("Evaluate", evaluate); var result = ConstantNull(); if (forge.EvaluationType != null) { var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true); result = LocalMethod(evalMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT); var forgeEvaluationType = forge.EvaluationType.GetBoxedType(); if (optCoercionType != null && forgeEvaluationType != optCoercionType.GetBoxedType()) { var coercer = SimpleNumberCoercerFactory.GetCoercer( forgeEvaluationType, optCoercionType.GetBoxedType()); evaluate.Block.DeclareVar(forgeEvaluationType, "result", result); result = coercer.CoerceCodegen(Ref("result"), forge.EvaluationType); } } evaluate.Block.BlockReturn(result); return evaluator; }
public static void GetEnumerableScalarCodegen( AggregationAccessorLastWEvalForge forge, AggregationStateLinearForge stateForge, AggregationAccessorForgeGetCodegenContext context) { CodegenMethod childExpr = CodegenLegoMethodExpression.CodegenExpression( forge.ChildNode, context.Method, context.ClassScope, true); context.Method.Block.DeclareVar<EventBean>( "bean", stateForge.AggregatorLinear.GetLastValueCodegen( context.ClassScope, context.Method, context.NamedMethods)) .DebugStack() .IfRefNullReturnNull("bean") .DeclareVar<EventBean[]>( "eventsPerStreamBuf", NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1))) .AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean")) .DeclareVar<object>( "value", LocalMethod(childExpr, Ref("eventsPerStreamBuf"), Constant(true), ConstantNull())) .IfRefNullReturnNull("value") .MethodReturn(StaticMethod(typeof(Collections), "SingletonList", Ref("value"))); }
public static CodegenExpression CodegenEvaluator( ExprForge forge, CodegenMethod method, Type originator, CodegenClassScope classScope) { var lambda = new CodegenExpressionLambda(method.Block) .WithParams(LAMBDA_PARAMS); if (forge.EvaluationType == null) { lambda.Block.BlockReturn(ConstantNull()); return NewInstance<ProxyExprEvaluator>(lambda); } else if (forge.EvaluationType == typeof(void)) { var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope); lambda.Block .LocalMethod( evalMethod, LAMBDA_REF_EPS, LAMBDA_REF_ISNEWDATA, LAMBDA_REF_EXPREVALCONTEXT) .BlockReturn(ConstantNull()); } else { var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true); lambda.Block.BlockReturn( LocalMethod( evalMethod, LAMBDA_REF_EPS, LAMBDA_REF_ISNEWDATA, LAMBDA_REF_EXPREVALCONTEXT)); } return NewInstance<ProxyExprEvaluator>(lambda); }
public static void GetValueCodegen( AggregationAccessorFirstLastIndexWEvalForge forge, AggregationAccessorForgeGetCodegenContext context) { AggregationStateLinearForge stateForge = (AggregationStateLinearForge) context.AccessStateForge; CodegenMethod getBeanFirstLastIndex = GetBeanFirstLastIndexCodegen( forge, context.Column, context.ClassScope, stateForge, context.Method, context.NamedMethods); context.Method.Block.DeclareVar<EventBean>("bean", LocalMethod(getBeanFirstLastIndex)) .DebugStack() .IfRefNullReturnNull("bean") .DeclareVar<EventBean[]>( "eventsPerStreamBuf", NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1))) .AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean")) .MethodReturn( LocalMethod( CodegenLegoMethodExpression.CodegenExpression( forge.ChildNode, context.Method, context.ClassScope, true), Ref("eventsPerStreamBuf"), ConstantTrue(), ConstantNull())); }
private CodegenExpressionInstanceField CodegenFormatFieldInit(CodegenClassScope classScope) { var formatEvalDtx = CodegenLegoMethodExpression.CodegenExpression( _formatter, classScope.NamespaceScope.InitMethod, classScope, true); var formatEval = LocalMethod(formatEvalDtx, ConstantNull(), ConstantTrue(), ConstantNull()); CodegenExpression init; if (_formatterType.FormatterType != typeof(string)) { init = formatEval; } else { var parse = classScope.NamespaceScope.InitMethod.MakeChild( typeof(DateFormat), GetType(), classScope); parse.Block.MethodReturn(NewInstance<SimpleDateFormat>(formatEval)); init = LocalMethod(parse); } return classScope.AddDefaultFieldUnshared( true, typeof(DateFormat), init); }
public CodegenExpression EvaluateMatchesCodegen( CodegenMethodScope parent, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(bool), GetType(), classScope); method.Block.ApplyTri(new ReturnIfNoMatch(ConstantFalse(), ConstantFalse()), method, symbols); if (filterEval == null && havingEval == null) { method.Block.MethodReturn(ConstantTrue()); return LocalMethod(method); } method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols); if (havingEval != null) { throw new UnsupportedOperationException(); } var filter = CodegenLegoMethodExpression.CodegenExpression(filterEval, method, classScope, true); method.Block .ForEach(typeof(EventBean), "subselectEvent", symbols.GetAddMatchingEvents(method)) .AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("subselectEvent")) .DeclareVar<bool?>( "pass", LocalMethod(filter, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method))) .IfCondition(And(NotEqualsNull(Ref("pass")), Unbox(Ref("pass")))) .BlockReturn(ConstantTrue()) .BlockEnd() .MethodReturn(ConstantFalse()); return LocalMethod(method); }
protected override CodegenExpression CodegenEvaluateInternal( CodegenMethodScope parent, SubselectForgeNRSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(bool?), GetType(), classScope); var eps = symbols.GetAddEPS(method); var evalCtx = symbols.GetAddExprEvalCtx(method); var left = symbols.GetAddLeftResult(method); method.Block.IfNullReturnNull(symbols.GetAddLeftResult(method)); if (havingEval != null) { CodegenExpression having = LocalMethod( CodegenLegoMethodExpression.CodegenExpression(havingEval, method, classScope, true), eps, ConstantTrue(), evalCtx); CodegenLegoBooleanExpression.CodegenReturnValueIfNullOrNotPass( method.Block, havingEval.EvaluationType, having, ConstantNull()); } CodegenExpression select = LocalMethod( CodegenLegoMethodExpression.CodegenExpression(selectEval, method, classScope, true), eps, ConstantTrue(), evalCtx); var rightEvalType = selectEval.EvaluationType.GetBoxedType(); method.Block .DeclareVar(rightEvalType, "rhs", select) .IfRefNullReturnNull("rhs"); if (coercer == null) { method.Block.DeclareVar<bool>("eq", ExprDotMethod(left, "Equals", Ref("rhs"))); if (isNot) { method.Block.IfCondition(Ref("eq")).BlockReturn(ConstantFalse()); } else { method.Block.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantFalse()); } } else { method.Block .DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType)) .DeclareVar<object>("right", coercer.CoerceCodegen(Ref("rhs"), rightEvalType)) .DeclareVar<bool>("eq", StaticMethod<object>("Equals", Ref("left"), Ref("right"))); if (isNot) { method.Block.IfCondition(Ref("eq")).BlockReturn(ConstantFalse()); } else { method.Block.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantFalse()); } } method.Block.MethodReturn(ConstantTrue()); return LocalMethod(method); }
public override CodegenExpression EvaluateGetCollScalarCodegen( CodegenMethodScope parent, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { if (subselect.FilterExpr == null) { if (subselect.SelectClause == null) { return ConstantNull(); } else { var method = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope); method.Block .DeclareVar<IList<object>>("result", NewInstance(typeof(List<object>))) .ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols); var selectClause = GetSelectClauseExpr(method, symbols, classScope); var @foreach = method.Block.ForEach( typeof(EventBean), "@event", symbols.GetAddMatchingEvents(method)); { @foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event")) .DeclareVar<object>("value", selectClause) .ExprDotMethod(Ref("result"), "Add", Ref("value")); } method.Block.MethodReturn(FlexWrap(Ref("result"))); return LocalMethod(method); } } if (subselect.SelectClause == null) { return ConstantNull(); } var methodX = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope); methodX.Block .DeclareVar<IList<object>>("result", NewInstance(typeof(List<object>))) .ApplyTri(DECLARE_EVENTS_SHIFTED, methodX, symbols); var selectClauseX = GetSelectClauseExpr(methodX, symbols, classScope); var filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, methodX, classScope, true); var foreachX = methodX.Block.ForEach( typeof(EventBean), "@event", symbols.GetAddMatchingEvents(methodX)); { foreachX.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event")); CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass( foreachX, typeof(bool?), LocalMethod( filter, REF_EVENTS_SHIFTED, symbols.GetAddIsNewData(methodX), symbols.GetAddExprEvalCtx(methodX))); foreachX.DeclareVar<object>("value", selectClauseX) .ExprDotMethod(Ref("result"), "Add", Ref("value")); } methodX.Block.MethodReturn(FlexWrap(Ref("result"))); return LocalMethod(methodX); }
private static CodegenMethod GetComparableWMultiKeyCodegen( ExprNode[] criteria, CodegenExpressionRef @ref, CodegenNamedMethods namedMethods, CodegenClassScope classScope) { var methodName = "GetComparable_" + @ref.Ref; Consumer<CodegenMethod> code = method => { if (criteria.Length == 1) { method.Block.MethodReturn( LocalMethod( CodegenLegoMethodExpression.CodegenExpression( criteria[0].Forge, method, classScope, true), REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); } else { var exprSymbol = new ExprForgeCodegenSymbol(true, null); var expressions = new CodegenExpression[criteria.Length]; for (var i = 0; i < criteria.Length; i++) { expressions[i] = criteria[i] .Forge.EvaluateCodegen( typeof(object), method, exprSymbol, classScope); } exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope); method.Block.DeclareVar<object[]>( "result", NewArrayByLength(typeof(object), Constant(criteria.Length))); for (var i = 0; i < criteria.Length; i++) { method.Block.AssignArrayElement(Ref("result"), Constant(i), expressions[i]); } method.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("result"))); } }; return namedMethods.AddMethod( typeof(object), methodName, CodegenNamedParam.From( typeof(EventBean[]), NAME_EPS, typeof(bool), NAME_ISNEWDATA, typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT), typeof(AggregatorAccessSortedImpl), classScope, code); }
public override CodegenExpression EvaluateCodegen( CodegenMethodScope parent, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { CodegenExpression aggService = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown( new CodegenFieldNameSubqueryAgg(subselect.SubselectNumber), typeof(AggregationResultFuture)); var method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope); var evalCtx = symbols.GetAddExprEvalCtx(method); method.Block .DeclareVar<int>("cpid", ExprDotName(evalCtx, "AgentInstanceId")) .DeclareVar<ICollection<object>>( "groupKeys", ExprDotMethod(aggService, "GetGroupKeys", evalCtx)) .IfCondition(Not(EqualsIdentity(ExprDotName(Ref("groupKeys"), "Count"), Constant(1)))) .BlockReturn(ConstantNull()) .ExprDotMethod( aggService, "SetCurrentAccess", ExprDotMethodChain(Ref("groupKeys")).Add("First"), Ref("cpid"), ConstantNull()) .ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols) .AssignArrayElement( REF_EVENTS_SHIFTED, Constant(0), StaticMethod( typeof(EventBeanUtility), "GetNonemptyFirstEvent", symbols.GetAddMatchingEvents(method))); 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 { var methodSelect = ExprNodeUtilityCodegen.CodegenMapSelect( subselect.SelectClause, subselect.SelectAsNames, this.GetType(), method, classScope); CodegenExpression select = LocalMethod( methodSelect, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)); method.Block.MethodReturn(select); } return LocalMethod(method); }
public CodegenExpression EvaluateGetROCollectionScalarCodegen( CodegenMethodScope parent, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { if (PreviousType == ExprPreviousNodePreviousType.PREVCOUNT) { return ConstantNull(); } if (PreviousType == ExprPreviousNodePreviousType.PREVWINDOW) { var methodX = parent.MakeChild(typeof(ICollection<object>), GetType(), codegenClassScope); methodX.Block .DeclareVar<PreviousGetterStrategy>( "strategy", ExprDotMethod( GetterField(codegenClassScope), "GetStrategy", exprSymbol.GetAddExprEvalCtx(methodX))) .Apply( new PreviousBlockGetSizeAndIterator(methodX, exprSymbol, StreamNumber, Ref("strategy")).Accept); var eps = exprSymbol.GetAddEPS(methodX); var innerEval = CodegenLegoMethodExpression.CodegenExpression( ChildNodes[1].Forge, methodX, codegenClassScope, true); methodX.Block .DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber))) .DeclareVar<ICollection<object>>("result", NewInstance<ArrayDeque<object>>(Ref("size"))) .ForLoopIntSimple("i", Ref("size")) .AssignArrayElement( eps, Constant(StreamNumber), Cast(typeof(EventBean), ExprDotMethod(Ref("events"), "Advance"))) .ExprDotMethod( Ref("result"), "Add", LocalMethod(innerEval, eps, ConstantTrue(), exprSymbol.GetAddExprEvalCtx(methodX))) .BlockEnd() .AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent")) .MethodReturn(Ref("result")); return LocalMethod(methodX); } var method = parent.MakeChild(typeof(ICollection<object>), GetType(), codegenClassScope); method.Block.DeclareVar<object>( "result", EvaluateCodegenPrevAndTail(method, exprSymbol, codegenClassScope)) .IfRefNullReturnNull("result") .MethodReturn(StaticMethod(typeof(Collections), "SingletonList", Ref("result"))); return LocalMethod(method); }
protected internal static CodegenMethod GenerateOrderKeyCodegen( string methodName, OrderByElementForge[] orderBy, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { Consumer<CodegenMethod> code = methodNode => { if (orderBy.Length == 1) { var expression = CodegenLegoMethodExpression.CodegenExpression( orderBy[0].ExprNode.Forge, methodNode, classScope, true); methodNode.Block.MethodReturn( LocalMethod( expression, EnumForgeCodegenNames.REF_EPS, ResultSetProcessorCodegenNames.REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return; } methodNode.Block.DeclareVar<object[]>( "keys", NewArrayByLength(typeof(object), Constant(orderBy.Length))); for (var i = 0; i < orderBy.Length; i++) { var expression = CodegenLegoMethodExpression.CodegenExpression( orderBy[i].ExprNode.Forge, methodNode, classScope, true); methodNode.Block.AssignArrayElement( "keys", Constant(i), LocalMethod( expression, EnumForgeCodegenNames.REF_EPS, ResultSetProcessorCodegenNames.REF_ISNEWDATA, REF_EXPREVALCONTEXT)); } methodNode.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("keys"))); }; return namedMethods.AddMethod( typeof(object), methodName, CodegenNamedParam.From( typeof(EventBean[]), NAME_EPS, typeof(bool), NAME_ISNEWDATA, typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT), typeof(ResultSetProcessorUtil), classScope, code); }
public static CodegenMethod GenerateGroupKeySingleCodegen( ExprNode[] groupKeyExpressions, MultiKeyClassRef optionalMultiKeyClasses, CodegenClassScope classScope, CodegenInstanceAux instance) { Consumer<CodegenMethod> code = methodNode => { string[] expressions = null; if (classScope.IsInstrumented) { expressions = ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(groupKeyExpressions); } methodNode.Block.Apply( Instblock( classScope, "qResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Constant(expressions), REF_EPS)); if (optionalMultiKeyClasses != null && optionalMultiKeyClasses.ClassNameMK != null) { var method = MultiKeyCodegen.CodegenMethod(groupKeyExpressions, optionalMultiKeyClasses, methodNode, classScope); methodNode .Block .DeclareVar<object>("key", LocalMethod(method, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT)) .Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key"))) .MethodReturn(Ref("key")); return; } if (groupKeyExpressions.Length > 1) { throw new IllegalStateException("Multiple group-by expression and no multikey"); } var expression = CodegenLegoMethodExpression.CodegenExpression(groupKeyExpressions[0].Forge, methodNode, classScope); methodNode .Block .DeclareVar<object>("key", LocalMethod(expression, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT)) .Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key"))) .MethodReturn(Ref("key")); }; return instance.Methods.AddMethod( typeof(object), "GenerateGroupKeySingle", CodegenNamedParam.From( typeof(EventBean[]), NAME_EPS, typeof(bool), ResultSetProcessorCodegenNames.NAME_ISNEWDATA), typeof(ResultSetProcessorUtil), classScope, code); }
public CodegenExpression MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent) { var method = parent.MakeChild(typeof(double), GetType(), classScope); var result = CodegenLegoMethodExpression.CodegenExpression(_runtimeConstant.Forge, method, classScope, true); method.Block.MethodReturn( ExprDotMethod( LocalMethod(result, ConstantNull(), ConstantTrue(), ConstantNull()), "AsDouble")); return LocalMethod(method); }
private static CodegenExpression FormatFieldExpr( Type type, ExprForge formatExpr, CodegenClassScope codegenClassScope) { var formatEval = CodegenLegoMethodExpression.CodegenExpression( formatExpr, codegenClassScope.NamespaceScope.InitMethod, codegenClassScope, true); CodegenExpression formatInit = LocalMethod(formatEval, ConstantNull(), ConstantTrue(), ConstantNull()); return codegenClassScope.AddDefaultFieldUnshared(true, type, formatInit); }
public CodegenExpression EventBeanWithCtxGet( CodegenExpression beanExpression, CodegenExpression ctxExpression, CodegenMethodScope parent, CodegenClassScope classScope) { var method = parent .MakeChild(typeof(object), GetType(), classScope) .AddParam(typeof(EventBean), "eventBean") .AddParam(typeof(ExprEvaluatorContext), "ctx"); var getImpl = CodegenLegoMethodExpression.CodegenExpression(_lookupable.Forge, method, classScope); method.Block .DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean"))) .MethodReturn(LocalMethod(getImpl, NewArrayWithInit(typeof(EventBean), Ref("eventBean")), ConstantTrue(), Ref("ctx"))); return LocalMethod(method, beanExpression, ctxExpression); }
public override CodegenExpression EvaluateCodegenUninstrumented( Type requiredType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { if (EvaluationType == typeof(void)) { return Noop(); } var initMethod = codegenClassScope.NamespaceScope.InitMethod; var evaluate = CodegenLegoMethodExpression.CodegenExpression(_inner, initMethod, codegenClassScope, true); return codegenClassScope.AddDefaultFieldUnshared( true, EvaluationType, LocalMethod(evaluate, ConstantNull(), ConstantTrue(), ConstantNull())); }
public CodegenExpression EventBeanGetCodegen( CodegenExpression beanExpression, CodegenMethodScope parent, CodegenClassScope codegenClassScope) { var method = parent.MakeChild(exprForge.EvaluationType, GetType(), codegenClassScope) .AddParam(typeof(EventBean), "bean"); var exprMethod = CodegenLegoMethodExpression.CodegenExpression(exprForge, method, codegenClassScope, true); method.Block .DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(1))) .AssignArrayElement(Ref("events"), Constant(0), Ref("bean")) .MethodReturn(LocalMethod(exprMethod, Ref("events"), ConstantTrue(), ConstantNull())); return LocalMethod(method, beanExpression); }
private CodegenExpression GetSelectClauseExpr( CodegenMethod method, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { if (subselect.SelectClause.Length == 1) { var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true); return LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)); } var methodSelect = ExprNodeUtilityCodegen.CodegenMapSelect( subselect.SelectClause, subselect.SelectAsNames, this.GetType(), method, classScope); return LocalMethod(methodSelect, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)); }
private static CodegenMethod GetBeanFirstLastIndexCodegen( AggregationAccessorFirstLastIndexWEvalForge forge, int column, CodegenClassScope classScope, AggregationStateLinearForge stateForge, CodegenMethod parent, CodegenNamedMethods namedMethods) { CodegenMethod method = parent.MakeChild( typeof(EventBean), typeof(AggregationAccessorFirstLastIndexWEval), classScope); if (forge.Constant == -1) { Type evalType = forge.IndexNode.EvaluationType; method.Block.DeclareVar( evalType, "indexResult", LocalMethod( CodegenLegoMethodExpression.CodegenExpression( forge.IndexNode, method, classScope, true), ConstantNull(), ConstantTrue(), ConstantNull())); if (evalType.CanBeNull()) { method.Block.IfRefNullReturnNull("indexResult"); } method.Block.DeclareVar<int>( "index", SimpleNumberCoercerFactory.CoercerInt.CodegenInt(Ref("indexResult"), evalType)); } else { method.Block.DeclareVar<int>("index", Constant(forge.Constant)); } CodegenExpression value = forge.IsFirst ? stateForge.AggregatorLinear.GetFirstNthValueCodegen(Ref("index"), method, classScope, namedMethods) : stateForge.AggregatorLinear.GetLastNthValueCodegen(Ref("index"), method, classScope, namedMethods); method.Block.MethodReturn(value); return method; }
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 CodegenExpression MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent) { var method = parent.MakeChild(typeof(object), GetType(), classScope).AddParam(GET_FILTER_VALUE_FP); var rhsExpression = CodegenLegoMethodExpression.CodegenExpression(value.Forge, method, classScope); var matchEventConvertor = convertor.Make(method, classScope); CodegenExpression valueExpr = LocalMethod(rhsExpression, Ref("eps"), ConstantTrue(), REF_EXPREVALCONTEXT); if (numberCoercer != null) { valueExpr = numberCoercer.CoerceCodegenMayNullBoxed(valueExpr, value.Forge.EvaluationType, method, classScope); } method.Block .DeclareVar<EventBean[]>("eps", LocalMethod(matchEventConvertor, REF_MATCHEDEVENTMAP)) .MethodReturn(valueExpr); return LocalMethod(method, GET_FILTER_VALUE_REFS); }
public CodegenExpression EventBeanGetCodegen( CodegenExpression beanExpression, CodegenMethodScope parent, CodegenClassScope classScope) { CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope) .AddParam(typeof(EventBean), "eventBean"); CodegenMethod methodExpr = CodegenLegoMethodExpression.CodegenExpression(eval.Forge, method, classScope, true); method.Block .DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean"))) .DeclareVar<object>("code", LocalMethod(methodExpr, Ref("events"), ConstantTrue(), ConstantNull())) .MethodReturn( StaticMethod( typeof(ContextControllerHashedGetterHashSingleForge), "ObjectToNativeHash", Ref("code"), Constant(granularity))); return LocalMethod(method, beanExpression); }
public static void GetValueCodegen( AggregationAccessorFirstWEvalForge forge, AggregationStateLinearForge accessStateFactory, AggregationAccessorForgeGetCodegenContext context) { CodegenMethod childExpr = CodegenLegoMethodExpression.CodegenExpression( forge.ChildNode, context.Method, context.ClassScope, true); context.Method.Block.DeclareVar<EventBean>( "bean", accessStateFactory.AggregatorLinear.GetFirstValueCodegen(context.ClassScope, context.Method)) .DebugStack() .IfRefNullReturnNull("bean") .DeclareVar<EventBean[]>( "eventsPerStreamBuf", NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1))) .AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean")) .MethodReturn(LocalMethod(childExpr, Ref("eventsPerStreamBuf"), Constant(true), ConstantNull())); }
public CodegenExpression EvaluateCodegenUninstrumented( Type requiredType, CodegenMethodScope parent, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var method = parent.MakeChild(EvaluationType, GetType(), codegenClassScope); var innerEval = CodegenLegoMethodExpression.CodegenExpression(InnerForge, method, codegenClassScope, true); var eps = exprSymbol.GetAddEPS(method); // see ExprPriorEvalStrategyBase CodegenExpression future = codegenClassScope.NamespaceScope.AddOrGetDefaultFieldWellKnown( priorStrategyFieldName, typeof(PriorEvalStrategy)); var innerMethod = LocalMethod( innerEval, eps, exprSymbol.GetAddIsNewData(method), exprSymbol.GetAddExprEvalCtx(method)); method.Block .DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber))) .DeclareVar<EventBean>( "substituteEvent", ExprDotMethod( future, "GetSubstituteEvent", Ref("originalEvent"), exprSymbol.GetAddIsNewData(method), Constant(ConstantIndexNumber), Constant(RelativeIndex), exprSymbol.GetAddExprEvalCtx(method), Constant(StreamNumber))) .AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent")) .DeclareVar(EvaluationType, "evalResult", innerMethod) .AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent")) .MethodReturn(Ref("evalResult")); return LocalMethod(method); }
public static void GetEnumerableScalarCodegen( AggregationAccessorWindowWEvalForge forge, AggregationStateLinearForge stateForge, AggregationAccessorForgeGetCodegenContext context) { context.Method.Block .DeclareVar<int>("size", stateForge.AggregatorLinear.SizeCodegen()) .IfCondition(EqualsIdentity(Ref("size"), Constant(0))) .BlockReturn(ConstantNull()) .DeclareVar<IList<object>>("values", NewInstance<List<object>>(Ref("size"))) .DeclareVar<IEnumerator<EventBean>>( "enumerator", stateForge.AggregatorLinear.EnumeratorCodegen( context.ClassScope, context.Method, context.NamedMethods)) .DebugStack() .DeclareVar<EventBean[]>( "eventsPerStreamBuf", NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1))) .WhileLoop(ExprDotMethod(Ref("enumerator"), "MoveNext")) .DeclareVar<EventBean>("bean", Cast(typeof(EventBean), ExprDotName(Ref("enumerator"), "Current"))) .AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean")) .DeclareVar( forge.ChildNode.EvaluationType.GetBoxedType(), "value", LocalMethod( CodegenLegoMethodExpression.CodegenExpression( forge.ChildNode, context.Method, context.ClassScope, true), Ref("eventsPerStreamBuf"), ConstantTrue(), ConstantNull())) .ExprDotMethod(Ref("values"), "Add", Ref("value")) .BlockEnd() .MethodReturn(Ref("values")); }
private CodegenExpression EvaluateCodegenPrevAndTail( CodegenMethodScope parent, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var method = parent.MakeChild(ResultType, GetType(), codegenClassScope); var eps = exprSymbol.GetAddEPS(method); var innerEval = CodegenLegoMethodExpression.CodegenExpression( ChildNodes[1].Forge, method, codegenClassScope, true); method.Block .IfCondition(Not(exprSymbol.GetAddIsNewData(method))) .BlockReturn(ConstantNull()) .DeclareVar<EventBean>( "substituteEvent", LocalMethod( GetSubstituteCodegen(method, exprSymbol, codegenClassScope), eps, exprSymbol.GetAddExprEvalCtx(method))) .IfRefNullReturnNull("substituteEvent") .DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber))) .AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent")) .DeclareVar( ResultType, "evalResult", LocalMethod( innerEval, eps, exprSymbol.GetAddIsNewData(method), exprSymbol.GetAddExprEvalCtx(method))) .AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent")) .MethodReturn(Ref("evalResult")); return LocalMethod(method); }
public CodegenExpression EvaluateMatchesCodegen( CodegenMethodScope parent, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(bool), GetType(), classScope); var havingMethod = CodegenLegoMethodExpression.CodegenExpression(havingEval, 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.CodegenReturnValueIfNullOrNotPass( method.Block, typeof(bool?), having, ConstantFalse()); method.Block.MethodReturn(ConstantTrue()); return LocalMethod(method); }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent .MakeChild(typeof(FilterSpecParam), GetType(), classScope); method.Block .DeclareVar <ExprFilterSpecLookupable>( "lookupable", LocalMethod(lookupable.MakeCodegen(method, symbols, classScope))) .DeclareVar <FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName())); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP); var inner = NewInstance <ProxyFilterSpecParam>( Ref("lookupable"), Ref("filterOperator"), getFilterValue); var rhsExpression = CodegenLegoMethodExpression.CodegenExpression(_value.Forge, method, classScope); var matchEventConvertor = _convertor.Make(method, classScope); CodegenExpression valueExpr = LocalMethod(rhsExpression, Ref("eps"), ConstantTrue(), REF_EXPREVALCONTEXT); if (_numberCoercer != null) { valueExpr = _numberCoercer.CoerceCodegenMayNullBoxed(valueExpr, _value.Forge.EvaluationType, method, classScope); } getFilterValue.Block .DeclareVar <EventBean[]>("eps", LocalMethod(matchEventConvertor, FilterSpecParam.REF_MATCHEDEVENTMAP)) .BlockReturn(FilterValueSetParamImpl.CodegenNew(valueExpr)); method.Block.MethodReturn(inner); return(method); }