public CodegenExpression Codegen(CodegenExpression inner, Type innerType, CodegenMethodScope parent, ExprForgeCodegenSymbol symbols, CodegenClassScope classScope) { Type type = EPTypeHelper.GetCodegenReturnType(_returnType); CodegenMethod method = parent .MakeChild(type, typeof(ExprDotForgeProperty), classScope) .AddParam(innerType, "target").AddParam(typeof(int?), "index"); var arrayExpr = CastSafeFromObjectType(_arrayType, _getter.EventBeanGetCodegen(Cast(typeof(EventBean), Ref("target")), method, classScope)); method.Block .IfNotInstanceOf("target", typeof(EventBean)) .BlockReturn(ConstantNull()) .DeclareVar(_arrayType, "array", arrayExpr) .IfRefNullReturnNull("index") .IfCondition(Relational(Ref("index"), CodegenExpressionRelational.CodegenRelational.GE, ArrayLength(Ref("array")))) .BlockThrow( NewInstance <EPException>( Concat( Constant("Array length "), ArrayLength(Ref("array")), Constant(" less than index "), Ref("index"), Constant(" for property '" + _propertyName + "'")))) .MethodReturn(CastSafeFromObjectType(type, ArrayAtIndex(Ref("array"), ExprDotMethod(Ref("index"), "AsInt32")))); return(LocalMethod(method, inner, _indexExpression.Forge.EvaluateCodegen(typeof(int?), method, symbols, classScope))); }
public static CodegenExpression Codegen( ExprDotForgeGetCollection forge, CodegenExpression inner, Type innerType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope.MakeChild( forge.TypeInfo.GetNormalizedClass(), typeof(ExprDotForgeGetCollectionEval), codegenClassScope) .AddParam(innerType, "target"); var block = methodNode.Block; if (!innerType.IsPrimitive) { block.IfRefNullReturnNull("target"); } var targetType = EPTypeHelper.GetCodegenReturnType(forge.TypeInfo); block.DeclareVar <int>("index", forge.IndexExpression.EvaluateCodegen(typeof(int), methodNode, exprSymbol, codegenClassScope)) .MethodReturn( CodegenLegoCast.CastSafeFromObjectType( targetType, StaticMethod( typeof(ExprDotForgeGetCollectionEval), "CollectionElementAt", Ref("target"), Ref("index")))); return(LocalMethod(methodNode, inner)); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType)); var paramTypes = EnumForgeCodegenNames.PARAMS; var block = codegenMethodScope .MakeChild(innerTypeBoxed, typeof(EnumMinMaxEventsForgeEval), codegenClassScope) .AddParam(paramTypes) .Block .DeclareVar(innerTypeBoxed, "minKey", ConstantNull()); var forEach = block.ForEach(typeof(object), "value", EnumForgeCodegenNames.REF_ENUMCOLL) .IfRefNull("value") .BlockContinue(); forEach.IfCondition(EqualsNull(Ref("minKey"))) .AssignRef("minKey", Cast(innerTypeBoxed, Ref("value"))) .IfElse() .IfCondition( Relational(ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")), _max ? LT : GT, Constant(0))) .AssignRef("minKey", Cast(innerTypeBoxed, Ref("value"))); var method = block.MethodReturn(Ref("minKey")); return LocalMethod(method, args.Expressions); }
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 EnumMinMaxByScalar( ExprDotEvalParamLambda lambda, ObjectArrayEventType fieldEventType, int numParameters, bool max, EPType resultType) : base(lambda, fieldEventType, numParameters) { this._max = max; this._resultType = resultType; this._innerTypeBoxed = Boxing.GetBoxedType(InnerExpression.EvaluationType); this._resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(resultType)); }
public CodegenExpression Codegen( CodegenExpression inner, Type innerType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { Type resultType = EPTypeHelper.GetCodegenReturnType(returnType); CodegenMethod methodNode = codegenMethodScope .MakeChild(resultType, typeof(ExprDotForgeUnpackBean), codegenClassScope) .AddParam(innerType, "target"); methodNode.Block .IfRefNullReturnNull("target") .MethodReturn(Cast(resultType, ExprDotUnderlying(Cast(typeof(EventBean), Ref("target"))))); return LocalMethod(methodNode, inner); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var type = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType)); var paramTypes = EnumForgeCodegenNames.PARAMS; var method = codegenMethodScope .MakeChild(type, typeof(EnumLastOfNoPredicateForge), codegenClassScope) .AddParam(paramTypes) .Block .DeclareVar<object>("result", ConstantNull()) .ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignRef("result", Ref("next")) .BlockEnd() .MethodReturn(Cast(type, Ref("result"))); return LocalMethod(method, args.Expressions); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var type = EPTypeHelper.GetCodegenReturnType(_resultType); var paramTypes = EnumForgeCodegenNames.PARAMS; var method = codegenMethodScope .MakeChild(type, typeof(EnumFirstOfNoPredicateForge), codegenClassScope) .AddParam(paramTypes) .Block .IfCondition( Or( EqualsNull(EnumForgeCodegenNames.REF_ENUMCOLL), ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))) .BlockReturn(ConstantNull()) .MethodReturn( Cast(type, ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First"))); return LocalMethod(method, args.Expressions); }
public static CodegenExpression Codegen( EnumLastOfPredicateScalarForge forge, EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var typeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(ObjectArrayEventType), Cast( typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF))); var resultType = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType)); var paramsType = EnumForgeCodegenNames.PARAMS; var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope .MakeChildWithScope(resultType, typeof(EnumLastOfPredicateScalarForgeEval), scope, codegenClassScope) .AddParam(paramsType); CodegenBlock block; block = methodNode.Block .DeclareVar<object>("result", ConstantNull()) .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("props", Constant(0), Ref("next")); CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass( forEach, forge.InnerExpression.EvaluationType, forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope)); forEach.AssignRef("result", Ref("next")); block.MethodReturn(Cast(resultType, Ref("result"))); return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx); }
public CodegenExpression Codegen( CodegenExpression inner, Type innerType, CodegenMethodScope parent, ExprForgeCodegenSymbol symbols, CodegenClassScope classScope) { var type = EPTypeHelper.GetCodegenReturnType(_returnType); if (innerType == typeof(EventBean)) { return(CodegenLegoCast.CastSafeFromObjectType(type, _getter.EventBeanFragmentCodegen(inner, parent, classScope))); } var methodNode = parent.MakeChild(type, typeof(ExprDotForgePropertyFragment), classScope).AddParam(innerType, "target"); methodNode.Block .IfInstanceOf("target", typeof(EventBean)) .BlockReturn( CodegenLegoCast.CastSafeFromObjectType(type, _getter.EventBeanFragmentCodegen(Cast(typeof(EventBean), inner), methodNode, classScope))) .MethodReturn(ConstantNull()); return(LocalMethod(methodNode, inner)); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { Type innerTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType)); CodegenBlock block = codegenMethodScope .MakeChild(innerTypeBoxed, typeof(EnumMinMaxScalarNoParam), codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS) .Block .DeclareVar(innerTypeBoxed, "minKey", ConstantNull()); CodegenBlock forEach = block .ForEach(innerTypeBoxed, "value", EnumForgeCodegenNames.REF_ENUMCOLL) .IfRefNull("value") .BlockContinue(); var compareTo = StaticMethod( typeof(SmartCompare), "Compare", Ref("minKey"), Ref("value")); forEach .IfCondition(EqualsNull(Ref("minKey"))) .AssignRef("minKey", FlexCast(innerTypeBoxed, Ref("value"))) .IfElse() .IfCondition(Relational(compareTo, _max ? LT : GT, Constant(0))) .AssignRef("minKey", FlexCast(innerTypeBoxed, Ref("value"))); CodegenMethod method = block.MethodReturn(Ref("minKey")); return(LocalMethod(method, args.Expressions)); }
public static CodegenExpression Codegen( ExprDotForgeEnumMethodBase forge, CodegenExpression inner, Type innerType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var returnType = EPTypeHelper.GetCodegenReturnType(forge.TypeInfo); var methodNode = codegenMethodScope .MakeChild(returnType, typeof(ExprDotForgeEnumMethodEval), codegenClassScope) .AddParam(innerType, "param"); methodNode.Block.DebugStack(); var refEPS = exprSymbol.GetAddEPS(methodNode); var refIsNewData = exprSymbol.GetAddIsNewData(methodNode); var refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode); var forgeMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(object), NewInstance(typeof(object))); var block = methodNode.Block; //block.Debug("param: {0}", ExprDotMethod(Ref("param"), "RenderAny")); if (innerType == typeof(EventBean)) { block.DeclareVar<FlexCollection>("coll", FlexEvent(Ref("param"))); } else if (innerType == typeof(object[])) { block.DeclareVar<FlexCollection>("coll", FlexWrap(Ref("param"))); } else if (innerType.IsGenericCollection()) { block.DeclareVar(innerType, "coll", Ref("param")); } else { throw new IllegalStateException("invalid type presented for unwrapping"); } block.DeclareVar<ExpressionResultCacheForEnumerationMethod>( "cache", ExprDotMethodChain(refExprEvalCtx) .Get("ExpressionResultCacheService") .Get("AllocateEnumerationMethod")); var premade = new EnumForgeCodegenParams( Ref("eventsLambda"), Ref("coll"), innerType, refIsNewData, refExprEvalCtx); if (forge.IsCache) { block .DeclareVar<ExpressionResultCacheEntryLongArrayAndObj>( "cacheValue", ExprDotMethod(Ref("cache"), "GetEnumerationMethodLastValue", forgeMember)) .IfCondition(NotEqualsNull(Ref("cacheValue"))) .BlockReturn(Cast(returnType, ExprDotName(Ref("cacheValue"), "Result"))) .IfRefNullReturnNull("coll") .DeclareVar<EventBean[]>( "eventsLambda", StaticMethod( typeof(ExprDotForgeEnumMethodEval), "AllocateCopyEventLambda", refEPS, Constant(forge.EnumEvalNumRequiredEvents))) .DeclareVar( EPTypeHelper.GetCodegenReturnType(forge.TypeInfo), "result", forge.EnumForge.Codegen(premade, methodNode, codegenClassScope)) .Expression( ExprDotMethod(Ref("cache"), "SaveEnumerationMethodLastValue", forgeMember, Ref("result"))) .MethodReturn(Ref("result")); } else { var contextNumberMember = codegenClassScope.AddDefaultFieldUnshared( true, typeof(AtomicLong), NewInstance(typeof(AtomicLong))); var returnInvocation = forge.EnumForge.Codegen(premade, methodNode, codegenClassScope); block .DeclareVar<long>("contextNumber", ExprDotMethod(contextNumberMember, "GetAndIncrement")) .TryCatch() .Expression(ExprDotMethod(Ref("cache"), "PushContext", Ref("contextNumber"))) .IfRefNullReturnNull("coll") .DeclareVar<EventBean[]>( "eventsLambda", StaticMethod( typeof(ExprDotForgeEnumMethodEval), "AllocateCopyEventLambda", refEPS, Constant(forge.EnumEvalNumRequiredEvents))) .TryReturn(CodegenLegoCast.CastSafeFromObjectType(returnType, returnInvocation)) .TryFinally() .Expression(ExprDotMethod(Ref("cache"), "PopContext")) .BlockEnd() .MethodEnd(); } return LocalMethod(methodNode, inner); }
public static CodegenExpression EvaluateChainCodegen( CodegenMethod parent, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope, CodegenExpression inner, Type innerType, ExprDotForge[] forges, ExprDotStaticMethodWrap optionalResultWrapLambda) { if (forges.Length == 0) { return inner; } var last = forges[forges.Length - 1]; var lastType = EPTypeHelper.GetCodegenReturnType(last.TypeInfo).GetBoxedType(); var methodNode = parent .MakeChild(lastType, typeof(ExprDotNodeUtility), codegenClassScope) .AddParam(innerType, "inner"); var block = methodNode.Block.DebugStack(); var currentTarget = "wrapped"; Type currentTargetType; if (optionalResultWrapLambda != null) { currentTargetType = EPTypeHelper.GetCodegenReturnType(optionalResultWrapLambda.TypeInfo); var wrapped = optionalResultWrapLambda.CodegenConvertNonNull(Ref("inner"), methodNode, codegenClassScope); if (currentTargetType == typeof(FlexCollection)) { wrapped = FlexWrap(wrapped); } block .IfRefNullReturnNull("inner") .DeclareVar(currentTargetType, "wrapped", wrapped); } else if (innerType == typeof(FlexCollection)) { block.DeclareVar(innerType, "wrapped", FlexWrap(Ref("inner"))); currentTargetType = innerType; } else { block.DeclareVar(innerType, "wrapped", Ref("inner")); currentTargetType = innerType; } string refname = null; var instrumentationName = new ExprDotEvalVisitorImpl(); for (var i = 0; i < forges.Length; i++) { refname = "r" + i; forges[i].Visit(instrumentationName); block.Apply( Instblock( codegenClassScope, "qExprDotChainElement", Constant(i), Constant(instrumentationName.MethodType), Constant(instrumentationName.MethodName))); var typeInformation = ConstantNull(); if (codegenClassScope.IsInstrumented) { typeInformation = codegenClassScope.AddOrGetDefaultFieldSharable( new EPTypeCodegenSharable(forges[i].TypeInfo, codegenClassScope)); } var reftype = forges[i].TypeInfo.GetCodegenReturnType().GetBoxedType(); if (reftype == typeof(void)) { block.Expression( forges[i] .Codegen( Ref(currentTarget), currentTargetType, methodNode, exprSymbol, codegenClassScope)) .Apply(Instblock(codegenClassScope, "aExprDotChainElement", typeInformation, ConstantNull())); } else { var invocation = forges[i] .Codegen( Ref(currentTarget), currentTargetType, methodNode, exprSymbol, codegenClassScope); // We can't assume anything about the return type. Unfortunately, we do not know the resultant type // of the forge... I must fix this. - TBD invocation = CodegenLegoCast.CastSafeFromObjectType(reftype, invocation); block.DeclareVar(reftype, refname, invocation); currentTarget = refname; currentTargetType = reftype; if (reftype.CanBeNull()) { block.IfRefNull(refname) .Apply( Instblock(codegenClassScope, "aExprDotChainElement", typeInformation, ConstantNull())) .BlockReturn(ConstantNull()); } block.Apply(Instblock(codegenClassScope, "aExprDotChainElement", typeInformation, Ref(refname))); } } if (lastType == typeof(void)) { block.MethodEnd(); } else { block.MethodReturn(Ref(refname)); } return LocalMethod(methodNode, inner); }