public static CodegenExpression Codegen( EnumSumEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerType = forge.InnerExpression.EvaluationType; var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope( forge.sumMethodFactory.ValueType.GetBoxedType(), typeof(EnumSumEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block; forge.sumMethodFactory.CodegenDeclare(block); var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")) .DeclareVar( innerType.GetBoxedType(), "value", forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope)); if (innerType.CanBeNull()) { forEach.IfRefNull("value").BlockContinue(); } forge.sumMethodFactory.CodegenEnterNumberTypedNonNull(forEach, Ref("value")); forge.sumMethodFactory.CodegenReturn(block); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression Codegen( EnumDistinctEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(FlexCollection), typeof(EnumDistinctEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .IfCondition(Relational(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), LE, Constant(1))) .BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL) .DeclareVar<IDictionary<object, EventBean>>("distinct", NewInstance(typeof(LinkedHashMap<object, EventBean>))); block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")) .DeclareVar( innerType, "comparable", forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope)) .IfCondition(Not(ExprDotMethod(Ref("distinct"), "CheckedContainsKey", Ref("comparable")))) .Expression(ExprDotMethod(Ref("distinct"), "Put", Ref("comparable"), Ref("next"))) .BlockEnd(); block.MethodReturn(FlexWrap(ExprDotName(Ref("distinct"), "Values"))); 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 CodegenMethod EvaluateRowCodegen( CodegenMethodScope parent, CodegenClassScope classScope) { var symbols = new ExprForgeCodegenSymbol(true, true); var method = parent.MakeChildWithScope( typeof(IDictionary<string, object>), typeof(CodegenLegoMethodExpression), symbols, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); var selectClause = SelectClause; var selectAsNames = SelectAsNames; var expressions = new CodegenExpression[selectClause.Length]; for (var i = 0; i < selectClause.Length; i++) { expressions[i] = selectClause[i].Forge.EvaluateCodegen(typeof(object), method, symbols, classScope); } symbols.DerivedSymbolsCodegen(method, method.Block, classScope); method.Block.DeclareVar<IDictionary<string, object>>( "map", NewInstance(typeof(HashMap<string, object>))); for (var i = 0; i < selectClause.Length; i++) { method.Block.ExprDotMethod(Ref("map"), "Put", Constant(selectAsNames[i]), expressions[i]); } method.Block.MethodReturn(Ref("map")); return method; }
private CodegenMethod EvaluateGetROCollectionScalarCodegenRewritten( CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var nodeObject = GetNodeObject(codegenClassScope); var scope = new ExprForgeCodegenSymbol(true, null); var methodNode = codegenMethodScope .MakeChildWithScope( typeof(ICollection<object>), typeof(ExprDeclaredForgeBase), scope, codegenClassScope) .AddParam(ExprForgeCodegenNames.PARAMS); CodegenExpression refEPS = scope.GetAddEPS(methodNode); CodegenExpression refExprEvalCtx = scope.GetAddExprEvalCtx(methodNode); // generate code for the inner value so we know its symbols and derived symbols var innerValue = ((ExprEnumerationForge) InnerForge).EvaluateGetROCollectionScalarCodegen( methodNode, scope, codegenClassScope); // produce derived symbols var block = methodNode.Block; scope.DerivedSymbolsCodegen(methodNode, block, codegenClassScope); if (isCache) { block .DeclareVar<ExpressionResultCacheForDeclaredExprLastColl>( "cache", ExprDotMethodChain(refExprEvalCtx) .Get("ExpressionResultCacheService") .Get("AllocateDeclaredExprLastColl")) .DeclareVar<ExpressionResultCacheEntryEventBeanArrayAndCollBean>( "entry", ExprDotMethod( Ref("cache"), "GetDeclaredExpressionLastColl", nodeObject, refEPS)) .IfCondition(NotEqualsNull(Ref("entry"))) .BlockReturn( Unwrap<object>(ExprDotName(Ref("entry"), "Result"))) .DeclareVar<ICollection<object>>("result", innerValue) .Expression( ExprDotMethod( Ref("cache"), "SaveDeclaredExpressionLastColl", nodeObject, refEPS, FlexWrap(Unwrap<EventBean>(Ref("result"))))); } else { block.DeclareVar<ICollection<object>>("result", innerValue); } block.MethodReturn(FlexWrap(Ref("result"))); return methodNode; }
public static CodegenExpression Codegen( EnumAllOfEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(bool), typeof(EnumAllOfEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block; block.IfConditionReturnConst(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"), true); var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")); CodegenLegoBooleanExpression.CodegenReturnBoolIfNullOrBool( forEach, forge.InnerExpression.EvaluationType, forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope), true, false, false, false); block.MethodReturn(ConstantTrue()); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenMethod CodegenMapSelect( IList<ExprNode> selectClause, string[] selectAsNames, Type generator, CodegenMethodScope parent, CodegenClassScope classScope) { var exprSymbol = new ExprForgeCodegenSymbol(true, null); var method = parent.MakeChildWithScope( typeof(IDictionary<string, object>), generator, exprSymbol, classScope) .AddParam(PARAMS); method.Block.DeclareVar<IDictionary<string, object>>( "map", NewInstance(typeof(HashMap<string, object>), Constant(selectAsNames.Length + 2))); var expressions = new CodegenExpression[selectAsNames.Length]; for (var i = 0; i < selectClause.Count; i++) { expressions[i] = selectClause[i].Forge.EvaluateCodegen(typeof(object), method, exprSymbol, classScope); } exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope); for (var i = 0; i < selectClause.Count; i++) { method.Block.ExprDotMethod(Ref("map"), "Put", Constant(selectAsNames[i]), expressions[i]); } method.Block.MethodReturn(Ref("map")); return method; }
public static CodegenExpression Codegen( EnumTakeForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var returnType = typeof(FlexCollection); var paramTypes = EnumForgeCodegenNames.PARAMS; var methodNode = codegenMethodScope.MakeChildWithScope( typeof(FlexCollection), typeof(EnumTakeForgeEval), scope, codegenClassScope) .AddParam(paramTypes); var sizeType = forge.SizeEval.EvaluationType; var block = methodNode.Block .DebugStack() .DeclareVar( sizeType, "size", forge.SizeEval.EvaluateCodegen(sizeType, methodNode, scope, codegenClassScope)); if (sizeType.CanBeNull()) { block.IfRefNullReturnNull("size"); } block.MethodReturn( StaticMethod( typeof(EnumTakeForgeEval), "EvaluateEnumTakeMethod", EnumForgeCodegenNames.REF_ENUMCOLL, SimpleNumberCoercerFactory.CoercerInt.CodegenInt(Ref("size"), sizeType))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression Codegen( EnumSequenceEqualForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var namedParams = EnumForgeCodegenNames.PARAMS; var methodNode = codegenMethodScope .MakeChildWithScope(typeof(bool), typeof(EnumSequenceEqualForgeEval), scope, codegenClassScope) .AddParam(namedParams); methodNode.Block.MethodReturn( StaticMethod( typeof(EnumSequenceEqualForgeEval), "EnumSequenceEqualsCompare", EnumForgeCodegenNames.REF_ENUMCOLL, forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))); return LocalMethod( methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public override CodegenExpression Codegen( EnumForgeCodegenParams premade, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { ExprForgeCodegenSymbol scope = new ExprForgeCodegenSymbol(false, null); CodegenMethod methodNode = codegenMethodScope .MakeChildWithScope(ReturnType(), this.GetType(), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); CodegenExpression returnIfEmpty = ReturnIfEmptyOptional(); if (returnIfEmpty != null) { methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(returnIfEmpty); } InitBlock(methodNode.Block, methodNode, scope, codegenClassScope); CodegenBlock forEach = methodNode.Block .ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next")); ForEachBlock(forEach, methodNode, scope, codegenClassScope); ReturnResult(methodNode.Block); return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx)); }
public CodegenMethod CodegenWithEventType( CodegenMethodScope parent, CodegenClassScope classScope) { var symbolsWithType = new SAIFFInitializeSymbolWEventType(); var method = parent.MakeChildWithScope(typeof(FilterSpecPlan), typeof(FilterSpecParamForge), symbolsWithType, classScope) .AddParam(typeof(EventType), SAIFFInitializeSymbolWEventType.REF_EVENTTYPE.Ref) .AddParam(typeof(EPStatementInitServices), SAIFFInitializeSymbol.REF_STMTINITSVC.Ref); if (Paths.Length == 0) { method.Block.MethodReturn(PublicConstValue(typeof(FilterSpecPlan), "EMPTY_PLAN")); return method; } method.Block.DeclareVar<FilterSpecPlanPath[]>("paths", NewArrayByLength(typeof(FilterSpecPlanPath), Constant(Paths.Length))); for (var i = 0; i < Paths.Length; i++) { method.Block.AssignArrayElement("paths", Constant(i), LocalMethod(Paths[i].Codegen(method, symbolsWithType, classScope))); } method.Block .DeclareVar<FilterSpecPlan>("plan", NewInstance(typeof(FilterSpecPlan))) .SetProperty(Ref("plan"), "Paths", Ref("paths")) .SetProperty(Ref("plan"), "FilterConfirm", OptionalEvaluator(FilterConfirm, method, classScope)) .SetProperty(Ref("plan"), "FilterNegate", OptionalEvaluator(FilterNegate, method, classScope)) .SetProperty(Ref("plan"), "Convertor", ConvertorForge == null ? ConstantNull() : ConvertorForge.MakeAnonymous(method, classScope)) .ExprDotMethod(Ref("plan"), "Initialize") .MethodReturn(Ref("plan")); return method; }
public static CodegenExpression Codegen( EnumToMapEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(IDictionary<string, object>), typeof(EnumToMapEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) })); block.DeclareVar<IDictionary<string, object>>("map", NewInstance(typeof(HashMap<string, object>))); block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")) .DeclareVar<string>( "key", forge.InnerExpression.EvaluateCodegen(typeof(string), methodNode, scope, codegenClassScope)) .DeclareVar<object>( "value", forge.secondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)) .Expression(ExprDotMethod(Ref("map"), "Put", Ref("key"), Ref("value"))); block.MethodReturn(Ref("map")); 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( EnumSelectFromEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope( typeof(ICollection<object>), typeof(EnumSelectFromEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(FlexEmpty()) .DeclareVar<ArrayDeque<object>>( "result", NewInstance<ArrayDeque<object>>(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"))); var forEach = block .ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")) .DeclareVar<object>( "item", forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)) .IfCondition(NotEqualsNull(Ref("item"))) .Expression(ExprDotMethod(Ref("result"), "Add", Ref("item"))); block.MethodReturn(FlexWrap(Ref("result"))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
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( 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 CodegenMethod CodegenMethod( ExprNode[] expressionNodes, MultiKeyClassRef multiKeyClassRef, CodegenMethodScope parent, CodegenClassScope classScope) { var eventUnpackMethod = parent .MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), CodegenSymbolProviderEmpty.INSTANCE, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); var exprSymbol = new ExprForgeCodegenSymbol(true, null); var exprMethod = eventUnpackMethod .MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); var expressions = new CodegenExpression[expressionNodes.Length]; for (var i = 0; i < expressionNodes.Length; i++) { var forge = expressionNodes[i].Forge; expressions[i] = CodegenExpressionMayCoerce(forge, multiKeyClassRef.MKTypes[i], exprMethod, exprSymbol, classScope); } var instance = multiKeyClassRef.ClassNameMK.Type != null ? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions) : NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions); exprSymbol.DerivedSymbolsCodegen(eventUnpackMethod, exprMethod.Block, classScope); exprMethod.Block.MethodReturn(instance); eventUnpackMethod.Block.MethodReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return(eventUnpackMethod); }
private CodegenMethod EvaluateCodegenRewritten( Type requiredType, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var nodeObject = GetNodeObject(codegenClassScope); var evaluationType = DetermineEvaluationType(requiredType); var scope = new ExprForgeCodegenSymbol(true, null); var methodNode = codegenMethodScope .MakeChildWithScope(evaluationType, typeof(ExprDeclaredForgeBase), scope, codegenClassScope) .AddParam(ExprForgeCodegenNames.PARAMS); CodegenExpression refEPS = scope.GetAddEPS(methodNode); CodegenExpression refExprEvalCtx = scope.GetAddExprEvalCtx(methodNode); // generate code for the inner value so we know its symbols and derived symbols var innerValue = InnerForge.EvaluateCodegen( requiredType, methodNode, scope, codegenClassScope); // produce derived symbols var block = methodNode.Block; scope.DerivedSymbolsCodegen(methodNode, block, codegenClassScope); if (isCache) { CodegenExpression eval = ExprDotName(Ref("entry"), "Result"); if (evaluationType != typeof(object)) { eval = Cast(InnerForge.EvaluationType, eval); } block .DeclareVar<ExpressionResultCacheForDeclaredExprLastValue>( "cache", ExprDotMethodChain(refExprEvalCtx) .Get("ExpressionResultCacheService") .Get("AllocateDeclaredExprLastValue")) .DeclareVar<ExpressionResultCacheEntryEventBeanArrayAndObj>( "entry", ExprDotMethod(Ref("cache"), "GetDeclaredExpressionLastValue", nodeObject, refEPS)) .IfCondition(NotEqualsNull(Ref("entry"))) .BlockReturn(eval) .DeclareVar(evaluationType, "result", innerValue) .Expression( ExprDotMethod( Ref("cache"), "SaveDeclaredExpressionLastValue", nodeObject, refEPS, Ref("result"))); } else { block.DeclareVar(evaluationType, "result", innerValue); } block.MethodReturn(Ref("result")); return methodNode; }
public static CodegenExpression Codegen( EnumMinMaxByScalarLambdaForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerType = forge.InnerExpression.EvaluationType; var innerTypeBoxed = Boxing.GetBoxedType(innerType); var resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType)); var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF))); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope( resultTypeBoxed, typeof(EnumMinMaxByScalarLambdaForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .DeclareVar(innerTypeBoxed, "minKey", ConstantNull()) .DeclareVar(resultTypeBoxed, "result", ConstantNull()) .DeclareVar<ObjectArrayEventBean>( "resultEvent", NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent")) .DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")) .DeclareVar( innerTypeBoxed, "value", forge.InnerExpression.EvaluateCodegen(innerTypeBoxed, methodNode, scope, codegenClassScope)) .IfRefNull("value") .BlockContinue(); forEach.IfCondition(EqualsNull(Ref("minKey"))) .AssignRef("minKey", Ref("value")) .AssignRef("result", Cast(resultTypeBoxed, Ref("next"))) .IfElse() .IfCondition( Relational( ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")), forge.max ? LT : GT, Constant(0))) .AssignRef("minKey", Ref("value")) .AssignRef("result", Cast(resultTypeBoxed, Ref("next"))); block.MethodReturn(Ref("result")); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public override CodegenExpression Codegen( EnumForgeCodegenParams premade, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(_resultEventType, EPStatementInitServicesConstants.REF))); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope(typeof(IDictionary <object, object>), GetType(), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var hasIndex = _numParameters >= 2; var hasSize = _numParameters >= 3; var returnIfEmpty = ReturnIfEmptyOptional(); if (returnIfEmpty != null) { methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(returnIfEmpty); } InitBlock(methodNode.Block, methodNode, scope, codegenClassScope); methodNode.Block .DeclareVar <ObjectArrayEventBean>( "resultEvent", NewInstance(typeof(ObjectArrayEventBean), NewArrayByLength(typeof(object), Constant(_numParameters)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("resultEvent")) .DeclareVar <object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); if (hasIndex) { methodNode.Block.DeclareVar <int>("count", Constant(-1)); } if (hasSize) { methodNode.Block.AssignArrayElement(Ref("props"), Constant(2), ExprDotName(REF_ENUMCOLL, "Count")); } var forEach = methodNode.Block .ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")); if (hasIndex) { forEach.IncrementRef("count").AssignArrayElement("props", Constant(1), Ref("count")); } ForEachBlock(forEach, methodNode, scope, codegenClassScope); ReturnResult(methodNode.Block); return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx)); }
public static CodegenExpression Codegen( EnumAverageScalarLambdaForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerType = forge.InnerExpression.EvaluationType; var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF))); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(double?), typeof(EnumAverageEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .DeclareVar<double>("sum", Constant(0d)) .DeclareVar<int>("count", Constant(0)) .DeclareVar<ObjectArrayEventBean>( "resultEvent", NewInstance<ObjectArrayEventBean>( NewArrayByLength(typeof(object), Constant(1)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent")) .DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")) .DeclareVar( innerType, "num", forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope)); if (innerType.CanBeNull()) { forEach.IfRefNull("num").BlockContinue(); } forEach.Increment("count") .AssignRef( "sum", Op( Ref("sum"), "+", SimpleNumberCoercerFactory.CoercerDouble.CodegenDouble(Ref("num"), innerType))) .BlockEnd(); block.IfCondition(EqualsIdentity(Ref("count"), Constant(0))) .BlockReturn(ConstantNull()) .MethodReturn(Op(Ref("sum"), "/", Ref("count"))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression Codegen( EnumAggregateEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var typeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen( forge.ResultEventType, EPStatementInitServicesConstants.REF))); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( forge.Initialization.EvaluationType, typeof(EnumAggregateEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var initType = forge.Initialization.EvaluationType; var initTypeBoxed = initType.GetBoxedType(); var unboxRequired = initType != initTypeBoxed; var innerType = forge.InnerExpression.EvaluationType; var block = methodNode.Block; block.DeclareVar( initTypeBoxed, "value", forge.Initialization.EvaluateCodegen(initType, methodNode, scope, codegenClassScope)) .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn( unboxRequired ? (CodegenExpression) ExprDotName(Ref("value"), "Value") : (CodegenExpression) Ref("value")); block.DeclareVar<ObjectArrayEventBean>( "resultEvent", NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent")) .DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("value")) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda + 1), Ref("next")) .AssignRef( "value", forge.InnerExpression.EvaluateCodegen( innerType, methodNode, scope, codegenClassScope)) .BlockEnd(); block.MethodReturn( unboxRequired ? (CodegenExpression) ExprDotName(Ref("value"), "Value") : (CodegenExpression) Ref("value")); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression Codegen( EnumMostLeastFrequentScalarLamdaForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF))); var returnType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType); var scope = new ExprForgeCodegenSymbol(false, null); var paramTypes = EnumForgeCodegenNames.PARAMS; var methodNode = codegenMethodScope .MakeChildWithScope( returnType, typeof(EnumMostLeastFrequentScalarLamdaForgeEval), scope, codegenClassScope) .AddParam(paramTypes); var block = methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(ConstantNull()) .DeclareVar<IDictionary<object, int>>("items", NewInstance(typeof(HashMap<object, int>))) .DeclareVar<ObjectArrayEventBean>( "resultEvent", NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent")) .DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")) .DeclareVar<object>( "item", forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)) .DeclareVar<int?>("existing", ExprDotMethod(Ref("items"), "GetBoxed", Ref("item"))) .IfCondition(EqualsNull(Ref("existing"))) .AssignRef("existing", Constant(1)) .IfElse() .Increment("existing") .BlockEnd() .ExprDotMethod(Ref("items"), "Put", Ref("item"), Unbox(Ref("existing"))); block.MethodReturn( Cast( returnType, StaticMethod( typeof(EnumMostLeastFrequentEventForgeEval), "GetEnumMostLeastFrequentResult", Ref("items"), Constant(forge.isMostFrequent)))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
protected override CodegenMethod CodegenConstructorInit( CodegenMethodScope parent, CodegenClassScope classScope) { var saiffInitializeSymbol = new SAIFFInitializeSymbol(); var method = parent.MakeChildWithScope(TypeOfFactory(), GetType(), saiffInitializeSymbol, classScope) .AddParam(typeof(EPStatementInitServices), REF_STMTINITSVC.Ref); method.Block.MethodReturn(LocalMethod(forge.InitializeCodegen(method, saiffInitializeSymbol, classScope))); return method; }
public override CodegenExpression Codegen( EnumForgeCodegenParams premade, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(_resultEventType, EPStatementInitServicesConstants.REF))); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope(typeof(IDictionary <object, object>), typeof(EnumToMapScalar), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var hasIndex = _numParameters >= 2; var hasSize = _numParameters >= 3; var block = methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(EnumValue(typeof(EmptyDictionary <object, object>), "Instance")); block.DeclareVar <IDictionary <object, object> >("map", NewInstance(typeof(NullableDictionary <object, object>))) .DeclareVar( typeof(ObjectArrayEventBean), "resultEvent", NewInstance(typeof(ObjectArrayEventBean), NewArrayByLength(typeof(object), Constant(_numParameters)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("resultEvent")) .DeclareVar <object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); if (hasIndex) { block.DeclareVar <int>("count", Constant(-1)); } if (hasSize) { block.AssignArrayElement(Ref("props"), Constant(2), ExprDotName(REF_ENUMCOLL, "Count")); } var forEach = block .ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")); if (hasIndex) { forEach.IncrementRef("count").AssignArrayElement("props", Constant(1), Ref("count")); } forEach .DeclareVar <object>("key", InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)) .DeclareVar <object>("value", _secondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)) .Expression(ExprDotMethod(Ref("map"), "Put", Ref("key"), Ref("value"))); block.MethodReturn(Ref("map")); return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx)); }
protected override CodegenMethod CodegenConstructorInit( CodegenMethodScope parent, CodegenClassScope classScope) { var saiffInitializeSymbol = new SAIFFInitializeSymbol(); var method = parent.MakeChildWithScope(TypeOfFactory(), GetType(), saiffInitializeSymbol, classScope) .AddParam(typeof(EPStatementInitServices), REF_STMTINITSVC.Ref); method.Block .ExprDotMethod(REF_STMTINITSVC, "ActivateVariable", Constant(_variableName), _serde.Codegen(method, classScope, null)) .MethodReturn(LocalMethod(_forge.InitializeCodegen(method, saiffInitializeSymbol, classScope))); return method; }
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 CodegenExpression Codegen( EnumAverageDecimalScalarLambdaForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerType = forge.InnerExpression.EvaluationType; var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF))); CodegenExpression math = codegenClassScope.AddOrGetDefaultFieldSharable(new MathContextCodegenField(forge.optionalMathContext)); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(decimal?), typeof(EnumAverageDecimalScalarLambdaForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block; block.DeclareVar<EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal>( "agg", NewInstance(typeof(EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal), math)) .DeclareVar<ObjectArrayEventBean>( "resultEvent", NewInstance<ObjectArrayEventBean>( NewArrayByLength(typeof(object), Constant(1)), resultTypeMember)) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent")) .DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties")); var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement("props", Constant(0), Ref("next")) .DeclareVar( innerType, "num", forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)); if (innerType.CanBeNull()) { forEach.IfRefNull("num").BlockContinue(); } forEach.Expression(ExprDotMethod(Ref("agg"), "Enter", Ref("num"))); block.MethodReturn(ExprDotName(Ref("agg"), "Value")); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression Codegen( EnumOrderByAscDescEventsForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerBoxedType = forge.InnerExpression.EvaluationType.GetBoxedType(); var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope( typeof(ICollection<EventBean>), typeof(EnumOrderByAscDescEventsForgeEval), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block .DeclareVar<OrderedDictionary<object, object>>( "sort", NewInstance(typeof(OrderedDictionary<object, object>))) .DeclareVar<bool>("hasColl", ConstantFalse()); block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next")) .DeclareVar( innerBoxedType, "value", forge.InnerExpression.EvaluateCodegen(innerBoxedType, methodNode, scope, codegenClassScope)) .DeclareVar<object>("entry", ExprDotMethod(Ref("sort"), "Get", Ref("value"))) .IfCondition(EqualsNull(Ref("entry"))) .Expression(ExprDotMethod(Ref("sort"), "Put", Ref("value"), Ref("next"))) .BlockContinue() .IfCondition(InstanceOf(Ref("entry"), typeof(ICollection<object>))) .ExprDotMethod(Cast(typeof(ICollection<object>), Ref("entry")), "Add", Ref("next")) .BlockContinue() .DeclareVar<Deque<object>>("coll", NewInstance<ArrayDeque<object>>(Constant(2))) .ExprDotMethod(Ref("coll"), "Add", Ref("entry")) .ExprDotMethod(Ref("coll"), "Add", Ref("next")) .ExprDotMethod(Ref("sort"), "Put", Ref("value"), Ref("coll")) .AssignRef("hasColl", ConstantTrue()) .BlockEnd(); block.MethodReturn( Unwrap<EventBean>( StaticMethod( typeof(EnumOrderByAscDescEventsForgeEval), "EnumOrderBySortEval", Ref("sort"), Ref("hasColl"), Constant(forge.descending)))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public static CodegenExpression CodegenGet( CodegenExpression beanExpression, ExprDotNodeForgeStaticMethod forge, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var exprSymbol = new ExprForgeCodegenSymbol(true, null); var methodNode = codegenMethodScope.MakeChildWithScope( forge.EvaluationType, typeof(ExprDotNodeForgeStaticMethodEval), exprSymbol, codegenClassScope) .AddParam(ExprForgeCodegenNames.PARAMS); var args = AllArgumentExpressions( forge.ChildForges, forge.StaticMethod, methodNode, exprSymbol, codegenClassScope); exprSymbol.DerivedSymbolsCodegen(methodNode, methodNode.Block, codegenClassScope); AppendArgExpressions(args, methodNode.Block); // try block var tryBlock = methodNode.Block.TryCatch(); var invoke = CodegenInvokeExpression( forge.TargetObject, forge.StaticMethod, args, codegenClassScope); tryBlock.BlockReturn(invoke); // exception handling AppendCatch( tryBlock, forge.StaticMethod, forge.OptionalStatementName, forge.ClassOrPropertyName, forge.IsRethrowExceptions, args); // end method methodNode.Block.MethodReturn(ConstantNull()); return LocalMethod( methodNode, NewArrayWithInit(typeof(EventBean), beanExpression), ConstantTrue(), ConstantNull()); }