public CodegenExpression ComputeCodegen(CodegenExpression doubleValue) { return Op(doubleValue, "/", Constant(1000d)); }
public CodegenExpression CoerceCodegen( CodegenExpression value, Type valueType) { return value; }
public CodegenExpression CoerceCodegen( CodegenExpression value, Type valueType) { return(CodegenFloat(value, valueType)); }
public CodegenExpression ToDateCodegen(CodegenExpression ts) { return StaticMethod(typeof(DateTimeEx), "UtcInstance", Op(ts, "/", Constant(1000))); }
public static CodegenExpression CodegenEvaluatorReturnObjectOrArrayWCoerce( ExprForge[] forges, Type[] targetTypes, bool arrayMultikeyWhenSingleEvaluator, CodegenMethod method, Type generator, CodegenClassScope classScope) { var evaluate = new CodegenExpressionLambda(method.Block) .WithParams(PARAMS); var evaluator = NewInstance <ProxyExprEvaluator>(evaluate); // CodegenMethod evaluate = CodegenMethod // .MakeParentNode(typeof(object), generator, classScope) // .AddParam(ExprForgeCodegenNames.PARAMS); // evaluator.AddMethod("evaluate", evaluate); var exprSymbol = new ExprForgeCodegenSymbol(true, null); var exprMethod = method .MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); var expressions = new CodegenExpression[forges.Length]; for (var i = 0; i < forges.Length; i++) { expressions[i] = forges[i].EvaluateCodegen(forges[i].EvaluationType, exprMethod, exprSymbol, classScope); } exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope); if (forges.Length == 0) { exprMethod.Block.MethodReturn(ConstantNull()); } else if (forges.Length == 1) { var evaluationType = forges[0].EvaluationType; CodegenExpression coerced; if (arrayMultikeyWhenSingleEvaluator && evaluationType.IsArray) { var clazz = MultiKeyPlanner.GetMKClassForComponentType(evaluationType.GetElementType()); coerced = NewInstance(clazz, expressions[0]); } else { coerced = ExprNodeUtilityCodegen.CodegenCoerce(expressions[0], evaluationType, targetTypes?[0], false); } exprMethod.Block.MethodReturn(coerced); } else { exprMethod.Block.DeclareVar <object[]>("values", NewArrayByLength(typeof(object), Constant(forges.Length))); for (var i = 0; i < forges.Length; i++) { var coerced = ExprNodeUtilityCodegen.CodegenCoerce( expressions[i], forges[i].EvaluationType, targetTypes?[i], false); exprMethod.Block.AssignArrayElement("values", Constant(i), coerced); } exprMethod.Block.MethodReturn(Ref("values")); } evaluate.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return(evaluator); }
public CodegenExpression Codegen(CodegenExpression input) => ProcCodegen?.Invoke(input);
public CodegenExpression CoerceCodegen( CodegenExpression value, Type valueType) { return(CodegenDecimal(value, valueType)); }
public SAIFFInitializeBuilder Expression( string name, CodegenExpression expression) { return SetValue(name, expression == null ? ConstantNull() : expression); }
public CodegenStatementThrow(CodegenExpression expression) { this.expression = expression; }
public CodegenBlock WhileLoop(CodegenExpression expression) { return WhileOrDoLoop(expression, true); }
public CodegenBlock DoLoop(CodegenExpression expression) { return WhileOrDoLoop(expression, false); }
public CodegenBlock IfRefNullThrowException( CodegenExpressionRef @ref, CodegenExpression exceptionGenerator) { return IfRefNull(@ref).BlockThrow(exceptionGenerator); }
public CodegenBlock DeclareVar<T>( string var, CodegenExpression initializer) { return DeclareVar(typeof(T), var, initializer); }
private JsonDelegateRefs(CodegenExpression baseHandler) { BaseHandler = baseHandler; }
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.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.cache) { 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 CodegenSetterBuilder Expression( string name, CodegenExpression expression) { return(SetValue(name, expression)); }
public override CodegenMethod ProcessCodegen( CodegenExpression resultEventType, CodegenExpression eventBeanFactory, CodegenMethodScope codegenMethodScope, SelectExprProcessorCodegenSymbol selectSymbol, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope); var manufacturer = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventBeanManufacturer), eventManufacturer.Make(methodNode.Block, codegenMethodScope, codegenClassScope)); var block = methodNode.Block .DeclareVar <object[]>( "values", CodegenExpressionBuilder.NewArrayByLength( typeof(object), CodegenExpressionBuilder.Constant(exprForges.Length))); for (var i = 0; i < exprForges.Length; i++) { var expression = CodegenLegoMayVoid.ExpressionMayVoid( exprForges[i].EvaluationType, exprForges[i], methodNode, exprSymbol, codegenClassScope); if (wideners[i] == null) { block.AssignArrayElement("values", CodegenExpressionBuilder.Constant(i), expression); } else { var refname = "evalResult" + i; block.DeclareVar(exprForges[i].EvaluationType, refname, expression); if (exprForges[i].EvaluationType.CanBeNull()) { block.IfRefNotNull(refname) .AssignArrayElement( "values", CodegenExpressionBuilder.Constant(i), wideners[i] .WidenCodegen( CodegenExpressionBuilder.Ref(refname), methodNode, codegenClassScope)) .BlockEnd(); } else { block.AssignArrayElement( "values", CodegenExpressionBuilder.Constant(i), wideners[i] .WidenCodegen( CodegenExpressionBuilder.Ref(refname), methodNode, codegenClassScope)); } } } block.MethodReturn( CodegenExpressionBuilder.ExprDotMethod( manufacturer, "Make", CodegenExpressionBuilder.Ref("values"))); return(methodNode); }
public abstract CodegenExpression Codegen( CodegenExpression inner, Type innerType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope);
public CodegenStatementReturnExpression(CodegenExpression expression) { _expression = expression ?? throw new ArgumentException("No expression provided"); }
public abstract CodegenExpression Codegen( CodegenExpression start, CodegenExpression end, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope);
public abstract CodegenExpression EventBeanGetCodegen( CodegenExpression beanExpression, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope);
public static CodegenExpression CodegenEvaluatorMayMultiKeyWCoerce( IList<ExprForge> forges, IList<Type> optCoercionTypes, CodegenMethod method, Type generator, CodegenClassScope classScope) { if (forges.Count == 1) { return CodegenEvaluatorWCoerce( forges[0], optCoercionTypes?[0], method, generator, 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<object>(generator, classScope).AddParam(PARAMS); //evaluator.AddMethod("Evaluate", evaluate); var exprSymbol = new ExprForgeCodegenSymbol(true, null); var exprMethod = method.MakeChildWithScope( typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(PARAMS); var exprBlock = exprMethod.Block; var expressions = new CodegenExpression[forges.Count]; for (var i = 0; i < forges.Count; i++) { expressions[i] = forges[i].EvaluateCodegen( forges[i].EvaluationType, exprMethod, exprSymbol, classScope); } exprSymbol.DerivedSymbolsCodegen(exprMethod, exprBlock, classScope); exprBlock.DeclareVar<object[]>( "values", NewArrayByLength(typeof(object), Constant(forges.Count))) .DeclareVar<HashableMultiKey>("valuesMk", NewInstance<HashableMultiKey>(Ref("values"))); for (var i = 0; i < forges.Count; i++) { var result = expressions[i]; if (optCoercionTypes != null && forges[i].EvaluationType.GetBoxedType() != optCoercionTypes[i].GetBoxedType()) { var coercer = SimpleNumberCoercerFactory.GetCoercer( forges[i].EvaluationType, optCoercionTypes[i].GetBoxedType()); var name = "result_" + i; exprBlock.DeclareVar(forges[i].EvaluationType, name, expressions[i]); result = coercer.CoerceCodegen(Ref(name), forges[i].EvaluationType); } exprBlock.AssignArrayElement("values", Constant(i), result); } exprBlock.ReturnMethodOrBlock(Ref("valuesMk")); evaluate.Block.ReturnMethodOrBlock( LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return evaluator; }
public CodegenMethod ProcessCodegen( CodegenExpression resultEventType, CodegenExpression eventBeanFactory, CodegenMethodScope codegenMethodScope, SelectExprProcessorCodegenSymbol selectSymbol, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), this.GetType(), codegenClassScope); methodNode.Block.DeclareVar(_jsonEventType.UnderlyingType, "und", NewInstanceInner(_jsonEventType.Detail.UnderlyingClassName)); for (var i = 0; i < _selectContext.ColumnNames.Length; i++) { var columnName = _selectContext.ColumnNames[i]; var fieldClassBoxed = Boxing.GetBoxedType(_jsonEventType.Detail.FieldDescriptors.Get(columnName).PropertyType); var propertyType = _jsonEventType.Types.Get(columnName); var evalType = _selectContext.ExprForges[i].EvaluationType; var field = _jsonEventType.Detail.FieldDescriptors.Get(_selectContext.ColumnNames[i]); CodegenExpression rhs = null; // handle if (evalType == typeof(EventBean)) { var conversion = methodNode.MakeChild(fieldClassBoxed, this.GetType(), codegenClassScope).AddParam(typeof(object), "value"); conversion.Block .IfRefNullReturnNull("value") .MethodReturn(Cast(fieldClassBoxed, ExprDotName(Cast(typeof(EventBean), Ref("value")), "Underlying"))); rhs = LocalMethod( conversion, CodegenLegoMayVoid.ExpressionMayVoid(typeof(EventBean), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope)); } else if (propertyType is Type) { rhs = CodegenLegoMayVoid.ExpressionMayVoid(fieldClassBoxed, _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope); } else if (propertyType is TypeBeanOrUnderlying) { var underlyingType = ((TypeBeanOrUnderlying)propertyType).EventType.UnderlyingType; var conversion = methodNode.MakeChild(underlyingType, this.GetType(), codegenClassScope).AddParam(typeof(object), "value"); conversion.Block .IfRefNullReturnNull("value") .IfInstanceOf("value", typeof(EventBean)) .BlockReturn(Cast(underlyingType, ExprDotUnderlying(Cast(typeof(EventBean), Ref("value"))))) .MethodReturn(Cast(underlyingType, Ref("value"))); rhs = LocalMethod( conversion, CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope)); } else if (propertyType is TypeBeanOrUnderlying[]) { var underlyingType = ((TypeBeanOrUnderlying[])propertyType)[0].EventType.UnderlyingType; var underlyingArrayType = TypeHelper.GetArrayType(underlyingType); var conversion = methodNode.MakeChild(underlyingArrayType, this.GetType(), codegenClassScope).AddParam(typeof(object), "value"); conversion.Block .IfRefNullReturnNull("value") .IfInstanceOf("value", underlyingArrayType) .BlockReturn(Cast(underlyingArrayType, Ref("value"))) .DeclareVar <EventBean[]>("events", Cast(typeof(EventBean[]), Ref("value"))) .DeclareVar(underlyingArrayType, "array", NewArrayByLength(underlyingType, ArrayLength(Ref("events")))) .ForLoopIntSimple("i", ArrayLength(Ref("events"))) .AssignArrayElement("array", Ref("i"), Cast(underlyingType, ExprDotUnderlying(ArrayAtIndex(Ref("events"), Ref("i"))))) .BlockEnd() .MethodReturn(Ref("array")); rhs = LocalMethod( conversion, CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope)); } else if (propertyType == null) { methodNode.Block.Expression( CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope)); } else { throw new UnsupportedOperationException("Unrecognized property "); } if (rhs != null) { if (field.PropertyType.IsPrimitive) { var tmp = "result_" + i; methodNode.Block .DeclareVar(fieldClassBoxed, tmp, rhs) .IfRefNotNull(tmp) .AssignRef(ExprDotName(Ref("und"), field.FieldName), Unbox(Ref(tmp), fieldClassBoxed)) .BlockEnd(); } else { methodNode.Block.AssignRef(ExprDotName(Ref("und"), field.FieldName), rhs); } } } methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("und"), resultEventType)); return(methodNode); }
public void ProviderCodegen( CodegenMethod method, CodegenClassScope classScope, AggregationClassNames classNames) { method.Block.DeclareVar<AggregationLocalGroupByLevel>("optionalTop", ConstantNull()); if (localGroupByPlan.OptionalLevelTopForge != null) { method.Block.AssignRef( "optionalTop", localGroupByPlan.OptionalLevelTopForge.ToExpression( classNames.RowFactoryTop, classNames.RowSerdeTop, ConstantNull(), method, classScope)); } int numLevels = localGroupByPlan.AllLevelsForges.Length; method.Block.DeclareVar<AggregationLocalGroupByLevel[]>( "levels", NewArrayByLength(typeof(AggregationLocalGroupByLevel), Constant(numLevels))); for (var i = 0; i < numLevels; i++) { AggregationLocalGroupByLevelForge forge = localGroupByPlan.AllLevelsForges[i]; CodegenExpression eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey( forge.PartitionForges, null, forge.PartitionMKClasses, method, classScope); method.Block.AssignArrayElement( "levels", Constant(i), localGroupByPlan.AllLevelsForges[i] .ToExpression( classNames.GetRowFactoryPerLevel(i), classNames.GetRowSerdePerLevel(i), eval, method, classScope)); } method.Block.DeclareVar<AggregationLocalGroupByColumn[]>( "columns", NewArrayByLength( typeof(AggregationLocalGroupByColumn), Constant(localGroupByPlan.ColumnsForges.Length))); var rowLevelDesc = RowLevelDesc; for (var i = 0; i < localGroupByPlan.ColumnsForges.Length; i++) { AggregationLocalGroupByColumnForge col = localGroupByPlan.ColumnsForges[i]; int fieldNum; if (hasGroupBy && col.IsDefaultGroupLevel) { AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum]; fieldNum = GetRowFieldNum(col, levelDesc); } else if (col.LevelNum == -1) { AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalTopRow; fieldNum = GetRowFieldNum(col, levelDesc); } else { AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum]; fieldNum = GetRowFieldNum(col, levelDesc); } method.Block.AssignArrayElement( "columns", Constant(i), localGroupByPlan.ColumnsForges[i].ToExpression(fieldNum)); } method.Block .DeclareVar<AggregationServiceFactory>( "svcFactory", NewInstanceInner(classNames.ServiceFactory, Ref("this"))) .MethodReturn( ExprDotMethodChain(EPStatementInitServicesConstants.REF) .Get(AGGREGATIONSERVICEFACTORYSERVICE) .Add( "GroupLocalGroupBy", Ref("svcFactory"), useFlags.ToExpression(), Constant(hasGroupBy), Ref("optionalTop"), Ref("levels"), Ref("columns"))); }
public CodegenExpression ComputeCodegen(CodegenExpression doubleValue) { return TimePeriodAdderUtil.ComputeCodegenTimesMultiplier(doubleValue, MULTIPLIER); }
public CodegenExpression CoerceBoxedBigIntCodegen( CodegenExpression expr, Type type) { return(CoerceCodegen(expr, type)); }
public CodegenExpression CoerceCodegen( CodegenExpression value, Type valueType) { return StaticMethod(typeof(ArrayCoercerFactory), "NarrowArray", value); }
private CodegenExpression MakeInstrumentationProvider( CodegenMethod method, CodegenClassScope classScope) { if (!_instrumented) { return ConstantNull(); } var instrumentation = Ref("instrumentation"); method.Block.AssignRef(instrumentation, NewInstance<ProxyInstrumentationCommon>()); //var anonymousClass = NewAnonymousClass( // method.Block, // typeof(InstrumentationCommon)); //var activated = CodegenMethod.MakeMethod(typeof(bool), GetType(), classScope); //activated.Block.MethodReturn(ConstantTrue()); method.Block.SetProperty( instrumentation, "ProcActivated", new CodegenExpressionLambda(method.Block) .WithBody( block => block.BlockReturn( ConstantTrue()))); foreach (var forwarded in typeof(InstrumentationCommon).GetMethods()) { if (forwarded.DeclaringType == typeof(object)) { continue; } if (forwarded.Name == "Activated") { continue; } IList<CodegenNamedParam> @params = new List<CodegenNamedParam>(); var forwardedParameters = forwarded.GetParameters(); var expressions = new CodegenExpression[forwardedParameters.Length]; var num = 0; foreach (var param in forwardedParameters) { @params.Add(new CodegenNamedParam(param.ParameterType, param.Name)); expressions[num] = Ref(param.Name); num++; } //var m = CodegenMethod.MakeMethod(typeof(void), GetType(), classScope) // .AddParam(@params); // Now we need a lambda to associate with the instrumentation and tie them together var proc = $"Proc{forwarded.Name}"; method.Block.SetProperty( instrumentation, "ProcActivated", new CodegenExpressionLambda(method.Block) .WithParams(@params) .WithBody( block => block .Apply( InstrumentationCode.Instblock( classScope, forwarded.Name, expressions)))); //instrumentation.AddMethod(forwarded.Name, m); } return instrumentation; }
public abstract CodegenExpression EventBeanWithCtxGet( CodegenExpression beanExpression, CodegenExpression ctxExpression, CodegenMethodScope parent, CodegenClassScope classScope);
public CodegenExpression ToDateCodegen(CodegenExpression ts) { return StaticMethod(typeof(DateTimeEx), "UtcInstance", ts); }