private static CodegenExpression CodegenMultikeyGetterBeanGet( EventPropertyGetterSPI[] getters, Type[] getterResultTypes, MultiKeyClassRef multiKeyClassRef, CodegenMethod method, CodegenClassScope classScope) { var get = new CodegenExpressionLambda(method.Block) .WithParams(CodegenNamedParam.From(typeof(EventBean), "bean")); var lambda = NewInstance <ProxyEventPropertyValueGetter>(get); var expressions = new CodegenExpression[getters.Length]; for (var i = 0; i < getters.Length; i++) { expressions[i] = getters[i].EventBeanGetCodegen(Ref("bean"), method, classScope); var mkType = multiKeyClassRef.MKTypes[i]; var getterType = getterResultTypes[i]; expressions[i] = ExprNodeUtilityCodegen.CodegenCoerce(expressions[i], getterType, mkType, true); } var instance = multiKeyClassRef.ClassNameMK.Type != null ? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions) : NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions); get.Block.BlockReturn(instance); return(lambda); }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent .MakeChild(typeof(FilterSpecParam), typeof(FilterSpecParamConstantForge), 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 inner = NewAnonymousClass( // method.Block, // typeof(FilterSpecParam), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); //var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP); //inner.AddMethod("GetFilterValue", getFilterValue); getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(Constant(FilterConstant))); method.Block.MethodReturn(inner); return method; }
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 CodegenExpression MakeTimePeriodAnonymous( CodegenMethod method, CodegenClassScope classScope) { //var timeClass = NewAnonymousClass(method.Block, typeof(TimePeriodEval)); //var evalMethod = CodegenMethod.MakeMethod(typeof(TimePeriod), GetType(), classScope) // .AddParam(PARAMS); //timeClass.AddMethod("timePeriodEval", evalMethod); var evalMethod = new CodegenExpressionLambda(method.Block).WithParams(PARAMS); var timeClass = NewInstance<ProxyTimePeriodEval>(evalMethod); var exprSymbol = new ExprForgeCodegenSymbol(true, true); //var exprMethod = evalMethod.MakeChildWithScope(typeof(TimePeriod), GetType(), exprSymbol, classScope); var exprMethod = method.MakeChild(typeof(TimePeriod), GetType(), classScope) .AddParam(PARAMS); CodegenExpression expression = forge.EvaluateGetTimePeriodCodegen(exprMethod, exprSymbol, classScope); //exprSymbol.DerivedSymbolsCodegen(evalMethod, exprMethod.Block, classScope); exprSymbol.DerivedSymbolsCodegen(exprMethod, exprMethod.Block, classScope); exprMethod.Block.MethodReturn(expression); evalMethod.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return timeClass; }
private CodegenExpression MakeAggAssignables( CodegenMethodScope parent, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(AggregationResultFutureAssignable[]), GetType(), classScope); method.Block .DeclareVar<AggregationResultFutureAssignable[]>( "assignables", NewArrayByLength(typeof(AggregationResultFutureAssignable), Constant(_aggregationServices.Length))); for (var i = 0; i < _aggregationServices.Length; i++) { if (_aggregationServices[i] != null) { var assign = new CodegenExpressionLambda(method.Block) .WithParam<AggregationResultFuture>("future"); var anonymousClass = NewInstance<ProxyAggregationResultFutureAssignable>(assign); //var anonymousClass = NewAnonymousClass(method.Block, typeof(AggregationResultFutureAssignable)); //var assign = CodegenMethod.MakeParentNode(typeof(void), GetType(), classScope) // .AddParam(typeof(AggregationResultFuture), "future"); //anonymousClass.AddMethod("assign", assign); var field = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown( new CodegenFieldNameMatchRecognizeAgg(i), typeof(AggregationResultFuture)); assign.Block.AssignRef(field, Ref("future")); method.Block.AssignArrayElement(Ref("assignables"), Constant(i), anonymousClass); } } method.Block.MethodReturn(Ref("assignables")); 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); getFilterValue .Block .BlockReturn(FilterValueSetParamImpl.CodegenNew(ConstantNull())); method.Block.MethodReturn(inner); return method; }
public CodegenExpression Make( CodegenBlock codegenBlock, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var init = codegenClassScope.NamespaceScope.InitMethod; var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); var eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(_jsonEventType, EPStatementInitServicesConstants.REF)); var makeUndFunc = new CodegenExpressionLambda(codegenBlock) .WithParam <object[]>("properties") .WithBody(block => MakeUnderlyingCodegen(block, codegenMethodScope, codegenClassScope)); var manufacturer = NewInstance <ProxyJsonEventBeanManufacturer>(eventType, factory, makeUndFunc); // CodegenExpressionNewAnonymousClass manufacturer = newAnonymousClass(init.getBlock(), EventBeanManufacturer.class); // // CodegenMethod makeUndMethod = CodegenMethod.makeParentNode(Object.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties"); // manufacturer.addMethod("makeUnderlying", makeUndMethod); // makeUnderlyingCodegen(makeUndMethod, codegenClassScope); // // CodegenMethod makeMethod = CodegenMethod.makeParentNode(EventBean.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties"); // manufacturer.addMethod("make", makeMethod); // makeMethod.getBlock() // .declareVar(Object.class, "und", localMethod(makeUndMethod, ref("properties"))) // .methodReturn(exprDotMethod(factory, "adapterForTypedJson", ref("und"), beanType)); return(codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer)); }
public CodegenExpression Make( CodegenBlock codegenBlock, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); var eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(_beanEventType, EPStatementInitServicesConstants.REF)); var makeUndLambda = new CodegenExpressionLambda(codegenBlock) .WithParam<object[]>("properties") .WithBody(block => MakeUnderlyingCodegen(codegenMethodScope, block, codegenClassScope)); var manufacturer = NewInstance<ProxyBeanEventBeanManufacturer>( eventType, factory, makeUndLambda); //var manufacturer = NewAnonymousClass(init.Block, typeof(EventBeanManufacturer)); //var makeUndMethod = CodegenMethod.MakeMethod(typeof(object), GetType(), codegenClassScope) // .AddParam(typeof(object[]), "properties"); //manufacturer.AddMethod("MakeUnderlying", makeUndMethod); //MakeUnderlyingCodegen(makeUndMethod, codegenClassScope); //var makeMethod = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope) // .AddParam(typeof(object[]), "properties"); //manufacturer.AddMethod("Make", makeMethod); //makeMethod.Block // .DeclareVar<object>("und", LocalMethod(makeUndMethod, Ref("properties"))) // .MethodReturn(ExprDotMethod(factory, "AdapterForTypedObject", Ref("und"), beanType)); return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer); }
public static void MakeSubstitutionSetter( CodegenNamespaceScope packageScope, CodegenBlock enclosingBlock, CodegenClassScope classScope) { var assignLambda = new CodegenExpressionLambda(enclosingBlock) .WithParam<StatementAIFactoryAssignments>("assignments"); //var assignMethod = CodegenMethod // .MakeParentNode(typeof(void), typeof(StmtClassForgableStmtFields), classScope) // .AddParam(typeof(StatementAIFactoryAssignments), "assignments"); //assignerSetterClass.AddMethod("Assign", assignMethod); assignLambda.Block.ExprDotMethod(Ref("statementFields"), "Assign", Ref("assignments")); //assignMethod.Block.StaticMethod(packageScope.FieldsClassName, "Assign", Ref("assignments")); var setValueMethod = new CodegenExpressionLambda(enclosingBlock) .WithParam(typeof(int), "index") .WithParam(typeof(object), "value"); //assignerSetterClass.AddMethod("SetValue", setValueMethod); var assignerSetterClass = NewInstance<ProxyFAFQueryMethodAssignerSetter>( assignLambda, setValueMethod); //var assignerSetterClass = NewAnonymousClass(enclosingBlock, typeof(FAFQueryMethodAssignerSetter)); enclosingBlock.ReturnMethodOrBlock(assignerSetterClass); CodegenSubstitutionParamEntry.CodegenSetterBody( classScope, setValueMethod.Block, Ref("statementFields")); }
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 CodegenExpression Make( CodegenBlock codegenBlock, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var factory = codegenClassScope.AddOrGetDefaultFieldSharable( EventBeanTypedEventFactoryCodegenField.INSTANCE); var eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(this.eventType, EPStatementInitServicesConstants.REF)); var makeUndLambda = new CodegenExpressionLambda(codegenBlock) .WithParam<object[]>("properties") .WithBody(block => MakeUnderlyingCodegen(block, codegenClassScope)); var manufacturer = NewInstance<ProxyObjectArrayEventBeanManufacturer>( eventType, factory, makeUndLambda); //var makeUndProc = CodegenMethod.MakeMethod(typeof(object[]), GetType(), codegenClassScope) // .AddParam(typeof(object[]), "properties"); //manufacturer.AddMethod("MakeUnderlying", makeUndProc); //MakeUnderlyingCodegen(makeUndProc, codegenClassScope); //var makeProc = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope) // .AddParam(typeof(object[]), "properties"); //manufacturer.AddMethod("Make", makeProc); return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer); }
public CodegenExpression Make( CodegenMethod parent, ModuleExpressionDeclaredInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(ExpressionDeclItem), GetType(), classScope); method.Block .DeclareVar<byte[]>( "bytes", Constant(OptionalSodaBytes.Invoke())); var supplierLambda = new CodegenExpressionLambda(method.Block); supplierLambda.Block.BlockReturn(Ref("bytes")); var supplierSodaBytes = NewInstance<Supplier<byte[]>>(supplierLambda); method.Block .DeclareVar<ExpressionDeclItem>( "item", NewInstance<ExpressionDeclItem>( Constant(Name), Constant(ParametersNames), Constant(IsAlias))) .SetProperty(Ref("item"), "OptionalSodaBytes", supplierSodaBytes) .SetProperty(Ref("item"), "ModuleName", Constant(ModuleName)) .SetProperty(Ref("item"), "Visibility", Constant(Visibility)) .MethodReturn(Ref("item")); return LocalMethod(method); }
public static CodegenExpression CodegenEvaluatorObjectArray( IList<ExprForge> forges, CodegenMethod method, Type generator, CodegenClassScope classScope) { var exprSymbol = new ExprForgeCodegenSymbol(true, null); //var evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator)); //var evaluate = CodegenMethod.MakeParentNode<object>(generator, classScope) // .AddParam(PARAMS); //evaluator.AddMethod("Evaluate", evaluate); var exprMethod = method .MakeChildWithScope( typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(PARAMS); 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, exprMethod.Block, classScope); exprMethod.Block.DeclareVar<object[]>( "values", NewArrayByLength(typeof(object), Constant(forges.Count))); for (var i = 0; i < forges.Count; i++) { var result = expressions[i]; exprMethod.Block.AssignArrayElement("values", Constant(i), result); } exprMethod.Block.MethodReturn(Ref("values")); var evaluate = new CodegenExpressionLambda(method.Block) .WithParams(PARAMS) .WithBody( block => block .BlockReturn( LocalMethod( exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT))); return NewInstance<ProxyExprEvaluator>(evaluate); }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent.MakeChild(typeof(FilterSpecParam), GetType(), classScope); var get = ExprIdentNodeEvaluator.Getter.EventBeanGetCodegen(Ref("@event"), method, classScope); method.Block .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(lookupable.MakeCodegen(method, symbols, classScope))) .DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator)); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP); var param = NewInstance<ProxyFilterSpecParam>( Ref("lookupable"), Ref("filterOperator"), getFilterValue); //var param = NewAnonymousClass( // method.Block, // typeof(FilterSpecParam), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); //var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP); //param.AddMethod("GetFilterValue", getFilterValue); getFilterValue.Block .DeclareVar<EventBean>( "@event", ExprDotMethod(Ref("matchedEvents"), "GetMatchingEventByTag", Constant(ResultEventAsName))) .DeclareVar<object>("value", ConstantNull()) .IfRefNotNull("@event") .AssignRef("value", get) .BlockEnd(); if (IsMustCoerce) { getFilterValue.Block.AssignRef( "value", _numberCoercer.CoerceCodegenMayNullBoxed( Cast(typeof(object), Ref("value")), typeof(object), method, classScope)); } getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("value"))); method.Block.MethodReturn(param); return method; }
public virtual CodegenMethod MakeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols, CodegenClassScope classScope) { var method = parent.MakeChild( typeof(ExprFilterSpecLookupable), typeof(ExprFilterSpecLookupableForge), classScope); CodegenExpression singleEventEvalExpr = ConstantNull(); if (_optionalEventEvalForge != null) { var eval = new CodegenExpressionLambda(method.Block) .WithParam<EventBean>("bean") .WithParam<ExprEvaluatorContext>("ctx"); var anonymous = NewInstance<ProxyExprEventEvaluator>(eval); eval.Block.BlockReturn( _optionalEventEvalForge.EventBeanWithCtxGet(Ref("bean"), Ref("ctx"), method, classScope)); singleEventEvalExpr = anonymous; } CodegenExpression epsEvalExpr = ConstantNull(); if (_optionalExprForge != null) { epsEvalExpr = ExprNodeUtilityCodegen.CodegenEvaluator( _optionalExprForge, method, typeof(ExprFilterSpecLookupableForge), classScope); } CodegenExpression serdeExpr = _valueSerde == null ? ConstantNull() : _valueSerde.Codegen(method, classScope, null); CodegenExpression returnTypeExpr = _returnType == null ? ConstantNull() : Typeof(_returnType); method.Block .DeclareVar<ExprEventEvaluator>("eval", singleEventEvalExpr) .DeclareVar<ExprEvaluator>("expr", epsEvalExpr) .DeclareVar<ExprFilterSpecLookupable>( "lookupable", NewInstance<ExprFilterSpecLookupable>( Constant(_expression), Ref("eval"), Ref("expr"), returnTypeExpr, Constant(_isNonPropertyGetter), serdeExpr)) .Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY) .Add( "RegisterLookupable", symbols.GetAddEventType(method), Ref("lookupable"))) .MethodReturn(Ref("lookupable")); return method; }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent.MakeChild(typeof(FilterSpecParam), GetType(), classScope); var lookupableExpr = LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)); method.Block .DeclareVar<ExprFilterSpecLookupable>("lookupable", lookupableExpr) .DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator)); //var param = NewAnonymousClass( // method.Block, // typeof(FilterSpecParam), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP); var param = NewInstance<ProxyFilterSpecParam>( Ref("lookupable"), Ref("filterOperator"), getFilterValue); //var getFilterValue = CodegenMethod // .MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP); //param.AddMethod("GetFilterValue", getFilterValue); getFilterValue.Block .DeclareVar<EventBean>("props", ExprDotName(REF_EXPREVALCONTEXT, "ContextProperties")) .IfNullReturnNull(Ref("props")) .DeclareVar<object>("result", _getter.EventBeanGetCodegen(Ref("props"), method, classScope)); if (_numberCoercer != null) { getFilterValue.Block.AssignRef( "result", _numberCoercer.CoerceCodegenMayNullBoxed( Cast(typeof(object), Ref("result")), typeof(object), method, classScope)); } var returnExpr = FilterValueSetParamImpl.CodegenNew(Ref("result")); getFilterValue.Block.BlockReturn(returnExpr); method.Block.MethodReturn(param); return method; }
public static CodegenExpression CodegenMultiKeyFromArrayTransform( MultiKeyClassRef optionalMultiKeyClasses, CodegenMethod method, CodegenClassScope classScope) { var fromLambda = new CodegenExpressionLambda(method.Block).WithParam <object[]>("keys"); var fromClass = NewInstance <ProxyMultiKeyFromObjectArray>(fromLambda); // CodegenExpressionNewAnonymousClass fromClass = NewAnonymousClass(method.Block, typeof(MultiKeyFromObjectArray)); // CodegenMethod from = CodegenMethod // .MakeParentNode(typeof(object), typeof(MultiKeyCodegen), classScope) // .AddParam(typeof(object[]), "keys"); // fromClass.AddMethod("from", from); if (optionalMultiKeyClasses == null || optionalMultiKeyClasses.ClassNameMK == null) { fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0))); } else if (optionalMultiKeyClasses.MKTypes.Length == 1) { var paramType = optionalMultiKeyClasses.MKTypes[0]; if (paramType == null || !paramType.IsArray) { fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0))); } else { var mktype = MultiKeyPlanner.GetMKClassForComponentType(paramType.GetElementType()); fromLambda.Block.BlockReturn(NewInstance(mktype, FlexCast(paramType, ArrayAtIndex(Ref("keys"), Constant(0))))); } } else { var expressions = new CodegenExpression[optionalMultiKeyClasses.MKTypes.Length]; for (var i = 0; i < expressions.Length; i++) { expressions[i] = FlexCast(optionalMultiKeyClasses.MKTypes[i], ArrayAtIndex(Ref("keys"), Constant(i))); } var instance = optionalMultiKeyClasses.ClassNameMK.Type != null ? NewInstance(optionalMultiKeyClasses.ClassNameMK.Type, expressions) : NewInstanceInner(optionalMultiKeyClasses.ClassNameMK.Name, expressions); fromLambda.Block.BlockReturn(instance); } return(fromClass); }
public CodegenExpression CodegenSerialize( JsonSerializerForgeRefs refs, CodegenMethod method, CodegenClassScope classScope) { // We need to encode the _subForge into a lambda of its own var itemSerializer = new CodegenExpressionLambda(method.Block) .WithBody(block => _subForge.CodegenSerialize(refs, method, classScope)); return(StaticMethod( typeof(JsonSerializerUtil), "WriteJsonList", refs.Context, refs.Field, itemSerializer)); }
public CodegenExpression InitCtorScoped() { var parse = new CodegenExpressionLambda(classScope.NamespaceScope.InitMethod.Block) .WithParam<string>("text"); var anonymousClass = NewInstance<ProxySimpleTypeParser>(parse); //CodegenExpressionNewAnonymousClass) anonymousClass = NewAnonymousClass( // classScope.NamespaceScope.InitMethod.Block, // typeof(SimpleTypeParser)); //CodegenMethod parse = CodegenMethod.MakeParentNode(typeof(object), this.GetType(), classScope) // .AddParam(typeof(string), "text"); //anonymousClass.AddMethod("Parse", parse); parse.Block.BlockReturn(parser.Codegen(Ref("text"))); return anonymousClass; }
public virtual CodegenMethod MakeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols, CodegenClassScope classScope) { var method = parent.MakeChild( typeof(ExprFilterSpecLookupable), typeof(ExprFilterSpecLookupableForge), classScope); CodegenExpression getterExpr; if (optionalEventPropForge != null) { var get = new CodegenExpressionLambda(method.Block) .WithParams(CodegenNamedParam.From(typeof(EventBean), "bean")); var anonymous = NewInstance<ProxyEventPropertyValueGetter>(get); //var anonymous = NewAnonymousClass(method.Block, typeof(EventPropertyValueGetter)); //var get = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(CodegenNamedParam.From(typeof(EventBean), "bean")); //anonymous.AddMethod("Get", get); get.Block.BlockReturn(optionalEventPropForge.EventBeanGetCodegen(Ref("bean"), method, classScope)); getterExpr = anonymous; } else { getterExpr = ConstantNull(); } method.Block.DeclareVar<EventPropertyValueGetter>("getter", getterExpr); method.Block .DeclareVar<ExprFilterSpecLookupable>( "lookupable", NewInstance<ExprFilterSpecLookupable>( Constant(expression), Ref("getter"), Typeof(returnType), Constant(isNonPropertyGetter))) .Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY) .Add( "RegisterLookupable", symbols.GetAddEventType(method), Ref("lookupable"))) .MethodReturn(Ref("lookupable")); return method; }
public CodegenExpression MakeWCopy( CodegenMethodScope scope, CodegenClassScope classScope) { var copyMethodField = classScope.AddDefaultFieldUnshared( true, typeof(EventBeanCopyMethod), _copyMethod.MakeCopyMethodClassScoped(classScope)); var method = scope.MakeChild(typeof(EventBeanUpdateHelperWCopy), GetType(), classScope); var updateInternal = MakeUpdateInternal(method, classScope); var updateWCopy = new CodegenExpressionLambda(method.Block) .WithParam(typeof(EventBean), "matchingEvent") .WithParam(typeof(EventBean[]), NAME_EPS) .WithParam(typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT); var clazz = NewInstance<EventBeanUpdateHelperWCopy>(updateWCopy); //var clazz = NewAnonymousClass(method.Block, typeof(EventBeanUpdateHelperWCopy)); //var updateWCopy = CodegenMethod.MakeParentNode(typeof(EventBean), GetType(), classScope) // .AddParam(typeof(EventBean), "matchingEvent") // .AddParam(typeof(EventBean[]), NAME_EPS) // .AddParam(typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT); //clazz.AddMethod("updateWCopy", updateWCopy); updateWCopy.Block .Apply( Instblock( classScope, "qInfraUpdate", Ref("matchingEvent"), REF_EPS, Constant(UpdateItems.Length), ConstantTrue())) .DeclareVar<EventBean>("copy", ExprDotMethod(copyMethodField, "Copy", Ref("matchingEvent"))) .AssignArrayElement(REF_EPS, Constant(0), Ref("copy")) .AssignArrayElement(REF_EPS, Constant(2), Ref("matchingEvent")) .LocalMethod(updateInternal, REF_EPS, REF_EXPREVALCONTEXT, Ref("copy")) .Apply(Instblock(classScope, "aInfraUpdate", Ref("copy"))) .ReturnMethodOrBlock(Ref("copy")); method.Block.MethodReturn(clazz); return LocalMethod(method); }
public static CodegenExpression CodegenWidener( TypeWidenerSPI widener, CodegenMethod method, Type originator, CodegenClassScope classScope) { var widen = new CodegenExpressionLambda(method.Block).WithParam<object>("input"); var anonymousClass = NewInstance<ProxyTypeWidener>(widen); //var anonymousClass = NewAnonymousClass(method.Block, typeof(TypeWidener)); //var widen = CodegenMethod.MakeParentNode(typeof(object), originator, classScope) // .AddParam(typeof(object), "input"); //anonymousClass.AddMethod("widen", widen); var widenResult = widener.WidenCodegen(Ref("input"), method, classScope); widen.Block.BlockReturn(widenResult); return anonymousClass; }
public static CodegenExpression MakeAnonymous( FilterSpecParamFilterForEvalDoubleForge eval, Type originator, CodegenClassScope classScope, CodegenMethod method) { var getFilterValueDouble = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP) .WithBody( block => block.BlockReturn( CodegenExpressionBuilder.Cast( typeof(double), eval.MakeCodegen(classScope, method)))); //anonymousClass.AddMethod("GetFilterValueDouble", getFilterValueDouble); //getFilterValueDouble.Block.MethodReturn( // CodegenExpressionBuilder.Cast( // typeof(double), // eval.MakeCodegen( // classScope, // getFilterValueDouble))); //var getFilterValue = new CodegenExpressionLambda(method.Block) // .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP) // .WithBody( // block => block.BlockReturn( // CodegenExpressionBuilder.ExprDotMethod( // CodegenExpressionBuilder.Ref("this"), // "GetFilterValueDouble", // FilterSpecParam.REF_MATCHEDEVENTMAP, // ExprForgeCodegenNames.REF_EXPREVALCONTEXT, // FilterSpecParam.REF_STMTCTXFILTEREVALENV))); //anonymousClass.AddMethod("GetFilterValue", getFilterValue); //getFilterValue.Block.MethodReturn( // CodegenExpressionBuilder.ExprDotMethod( // CodegenExpressionBuilder.Ref("this"), // "GetFilterValueDouble", // FilterSpecParam.REF_MATCHEDEVENTMAP, // ExprForgeCodegenNames.REF_EXPREVALCONTEXT, // FilterSpecParam.REF_STMTCTXFILTEREVALENV)); return(CodegenExpressionBuilder.NewInstance <ProxyFilterSpecParamFilterForEvalDouble>(getFilterValueDouble)); }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent.MakeChild(typeof(FilterSpecParam), typeof(FilterSpecParamConstantForge), classScope); method.Block .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(lookupable.MakeCodegen(method, symbols, classScope))) .DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator)); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP); var param = NewInstance<ProxyFilterSpecParam>( Ref("lookupable"), Ref("filterOperator"), getFilterValue); //var param = NewAnonymousClass( // method.Block, // typeof(FilterSpecParam), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); //var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP); //param.AddMethod("GetFilterValue", getFilterValue); var returnType = typeof(DoubleRange); var castType = typeof(double?); if (lookupable.ReturnType == typeof(string)) { castType = typeof(string); returnType = typeof(StringRange); } getFilterValue.Block .DeclareVar<object>("min", _min.MakeCodegen(classScope, method)) .DeclareVar<object>("max", _max.MakeCodegen(classScope, method)) .DeclareVar<object>("value", NewInstance(returnType, Cast(castType, Ref("min")), Cast(castType, Ref("max")))) .BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("value"))); method.Block.MethodReturn(param); return method; }
public static CodegenExpression CodegenSimpleParser( SimpleTypeParserSPI parser, CodegenMethod method, Type originator, CodegenClassScope classScope) { var parse = new CodegenExpressionLambda(method.Block) .WithParam <string>("value"); var typeParser = NewInstance <ProxySimpleTypeParser>(parse); //var anonymousClass = // NewAnonymousClass(method.Block, typeof(SimpleTypeParser)); //var parse = CodegenMethod // .MakeParentNode<object>(originator, classScope) // .AddParam<string>("value"); //anonymousClass.AddMethod("Parse", parse); parse.Block.BlockReturn(parser.Codegen(Ref("value"))); return(typeParser); }
private static CodegenExpression CodegenMultiKeyExprEvaluator( ExprForge[] expressionNodes, MultiKeyClassRef multiKeyClassRef, CodegenMethod method, CodegenClassScope classScope) { var evaluate = new CodegenExpressionLambda(method.Block) .WithParams(PARAMS); var evaluator = NewInstance <ProxyExprEvaluator>(evaluate); // CodegenExpressionNewAnonymousClass evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator)); // CodegenMethod evaluate = CodegenMethod // .MakeParentNode(typeof(object), typeof(StmtClassForgeableMultiKey), 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[expressionNodes.Length]; for (var i = 0; i < expressionNodes.Length; i++) { expressions[i] = CodegenExpressionMayCoerce(expressionNodes[i], multiKeyClassRef.MKTypes[i], exprMethod, exprSymbol, classScope); } var instance = multiKeyClassRef.ClassNameMK.Type != null ? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions) : NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions); exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope); exprMethod.Block.MethodReturn(instance); evaluate.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT)); return(evaluator); }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.MakeChild(typeof(ContainedEventEvalGetter), this.GetType(), classScope); var getFragment = new CodegenExpressionLambda(method.Block) .WithParams(new CodegenNamedParam(typeof(EventBean), "@event")); var anonymousClass = NewInstance<ProxyEventPropertyFragmentGetter>(getFragment); //var anonymousClass = NewAnonymousClass( // method.Block, // typeof(EventPropertyFragmentGetter)); //var getFragment = CodegenMethod.MakeParentNode(typeof(object), this.GetType(), classScope) // .AddParam(typeof(EventBean), "@event"); //anonymousClass.AddMethod("GetFragment", getFragment); getFragment.Block.BlockReturn(getter.EventBeanFragmentCodegen(Ref("@event"), method /* getFragment */, classScope)); method.Block.MethodReturn(NewInstance<ContainedEventEvalGetter>(anonymousClass)); 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); }
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(filterOperator)); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP); var param = NewInstance<ProxyFilterSpecParam>( Ref("lookupable"), Ref("filterOperator"), getFilterValue); //var param = NewAnonymousClass( // method.Block, // typeof(FilterSpecParam), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); //var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope) // .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP); //param.AddMethod("GetFilterValue", getFilterValue); var value = _deployTimeConstant.CodegenGetDeployTimeConstValue(classScope); if (_numberCoercer != null) { value = _numberCoercer.CoerceCodegenMayNullBoxed(value, _returnType, method, classScope); } getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(value)); method.Block.MethodReturn(param); return method; }
public CodegenExpression CodegenSerialize( JsonSerializerForgeRefs refs, CodegenMethod method, CodegenClassScope classScope) { var subRefs = new JsonSerializerForgeRefs( Ref("_context"), Ref("_arrayItem"), Ref("_name")); var serializationExpr = _subForge.CodegenSerialize(subRefs, method, classScope); var itemSerializer = new CodegenExpressionLambda(method.Block) .WithParam(typeof(JsonSerializationContext), "_context") .WithParam(_componentType, "_arrayItem") .WithBody(block => block.Expression(serializationExpr)); return(StaticMethod( typeof(JsonSerializerUtil), "WriteNestedArray", refs.Context, refs.Field, itemSerializer)); }