private CodegenExpression EvaluateCodegenPrevAndTail( CodegenMethodScope parent, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var method = parent.MakeChild(ResultType, GetType(), codegenClassScope); var eps = exprSymbol.GetAddEPS(method); var innerEval = CodegenLegoMethodExpression.CodegenExpression( ChildNodes[1].Forge, method, codegenClassScope, true); method.Block .IfCondition(Not(exprSymbol.GetAddIsNewData(method))) .BlockReturn(ConstantNull()) .DeclareVar<EventBean>( "substituteEvent", LocalMethod( GetSubstituteCodegen(method, exprSymbol, codegenClassScope), eps, exprSymbol.GetAddExprEvalCtx(method))) .IfRefNullReturnNull("substituteEvent") .DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber))) .AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent")) .DeclareVar( ResultType, "evalResult", LocalMethod( innerEval, eps, exprSymbol.GetAddIsNewData(method), exprSymbol.GetAddExprEvalCtx(method))) .AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent")) .MethodReturn(Ref("evalResult")); return LocalMethod(method); }
private CodegenMethod MakeFieldDescCodegen( CodegenMethodScope parent, CodegenClassScope classScope) { var method = parent .MakeChild( typeof(IDictionary<string, JsonUnderlyingField>), typeof(JsonEventTypeDetail), classScope); method.Block.DeclareVar( typeof(IDictionary<string, JsonUnderlyingField>), "fields", NewInstance(typeof(Dictionary<string, JsonUnderlyingField>))); foreach (var entry in FieldDescriptors) { method.Block.ExprDotMethod(Ref("fields"), "Put", Constant(entry.Key), entry.Value.ToCodegenExpression()); } method.Block.MethodReturn(Ref("fields")); return method; }
public CodegenExpression Make( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var builder = new SAIFFInitializeBuilder( OP_PACKAGE_NAME + ".eventbussource.EventBusSourceFactory", GetType(), "eventbussource", parent, symbols, classScope); builder.Expression( "filterSpecActivatable", LocalMethod( FilterSpecCompiled.MakeCodegen( builder.Method(), symbols, classScope))) .Constant("IsSubmitEventBean", submitEventBean); return builder.Build(); }
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 static CodegenExpression Codegen( DTLocalDtoIntervalForge forge, CodegenExpression inner, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { CodegenMethod methodNode = codegenMethodScope .MakeChild(typeof(bool?), typeof(DTLocalDtoIntervalEval), codegenClassScope) .AddParam(typeof(DateTimeOffset), "target"); methodNode.Block .DeclareVar<long>( "time", StaticMethod( typeof(DatetimeLongCoercerDateTimeOffset), "CoerceToMillis", Ref("target"))) .MethodReturn( forge.intervalForge.Codegen(Ref("time"), Ref("time"), methodNode, exprSymbol, codegenClassScope)); return LocalMethod(methodNode, inner); }
public static CodegenExpression CodegenEvaluators( IList<ExprForge> expressions, CodegenMethodScope parent, Type originator, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(ExprEvaluator[]), originator, classScope); method.Block.DeclareVar<ExprEvaluator[]>( "evals", NewArrayByLength(typeof(ExprEvaluator), Constant(expressions.Count))); for (var i = 0; i < expressions.Count; i++) { method.Block.AssignArrayElement( "evals", Constant(i), expressions[i] == null ? ConstantNull() : CodegenEvaluator(expressions[i], method, originator, classScope)); } method.Block.MethodReturn(Ref("evals")); return LocalMethod(method); }
public static CodegenExpression CoerceCodegenMayNull( CodegenExpression value, Type valueType, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { return(((valueType != typeof(short)) && (valueType != typeof(int)) && (valueType != typeof(int?))) ? CodegenExpressionBuilder.ExprDotMethod(value, "AsBoxedInt32") : value); // return CodegenCoerceMayNull( // typeof(int), // typeof(int?), // "AsInt32", // param, // type, // codegenMethodScope, // typeof(CoercerInt), // codegenClassScope); }
protected internal static CodegenMethod SortWGroupKeysInternalCodegen( OrderByProcessorForgeImpl forge, CodegenClassScope classScope, CodegenNamedMethods namedMethods) { var createSortProperties = CreateSortPropertiesCodegen(forge, classScope, namedMethods); CodegenExpression comparator = classScope.AddOrGetDefaultFieldSharable(forge.IComparer); Consumer<CodegenMethod> code = method => { method.Block.DeclareVar<IList<object>>( "sortValuesMultiKeys", LocalMethod( createSortProperties, REF_GENERATINGEVENTS, Ref("groupByKeys"), REF_ISNEWDATA, REF_EXPREVALCONTEXT, MEMBER_AGGREGATIONSVC)) .MethodReturn( StaticMethod( typeof(OrderByProcessorUtil), "SortGivenOutgoingAndSortKeys", REF_OUTGOINGEVENTS, Ref("sortValuesMultiKeys"), comparator)); }; return namedMethods.AddMethod( typeof(EventBean[]), "SortWGroupKeysInternal", CodegenNamedParam.From( typeof(EventBean[]), REF_OUTGOINGEVENTS.Ref, typeof(EventBean[][]), REF_GENERATINGEVENTS.Ref, typeof(object[]), "groupByKeys", typeof(bool), REF_ISNEWDATA.Ref, typeof(ExprEvaluatorContext), REF_EXPREVALCONTEXT.Ref, typeof(AggregationService), MEMBER_AGGREGATIONSVC.Ref), typeof(OrderByProcessorImpl), classScope, code); }
private CodegenMethod GetAvroFragmentCodegen( CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); var eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(_fragmentEventType, EPStatementInitServicesConstants.REF)); return codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope) .AddParam(typeof(GenericRecord), "record") .Block .DeclareVar<object>( "value", UnderlyingGetCodegen(Ref("record"), codegenMethodScope, codegenClassScope)) .MethodReturn( ExprDotMethod( factory, "AdapterForTypedAvro", Ref("value"), eventType)); }
internal static CodegenMethod GetAvroFieldValuePolyExistsCodegen( CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope, AvroEventPropertyGetter[] getters) { return codegenMethodScope.MakeChild(typeof(bool), typeof(AvroEventBeanGetterDynamicPoly), codegenClassScope) .AddParam(typeof(GenericRecord), "record") .Block .IfRefNullReturnFalse("record") .AssignRef( "record", CodegenExpressionBuilder.LocalMethod( NavigatePolyCodegen(codegenMethodScope, codegenClassScope, getters), CodegenExpressionBuilder.Ref("record"))) .IfRefNullReturnFalse("record") .MethodReturn( getters[getters.Length - 1] .UnderlyingExistsCodegen( CodegenExpressionBuilder.Ref("record"), codegenMethodScope, codegenClassScope)); }
public CodegenExpression EventBeanGetCodegen( CodegenExpression beanExpression, CodegenMethodScope parent, CodegenClassScope classScope) { CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope) .AddParam(typeof(EventBean), "eventBean"); CodegenMethod methodExpr = CodegenLegoMethodExpression.CodegenExpression(eval.Forge, method, classScope, true); method.Block .DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean"))) .DeclareVar<string>( "code", Cast(typeof(string), LocalMethod(methodExpr, Ref("events"), ConstantTrue(), ConstantNull()))) .MethodReturn( StaticMethod( typeof(ContextControllerHashedGetterCRC32SingleForge), "StringToCRC32Hash", Ref("code"), Constant(granularity))); return LocalMethod(method, beanExpression); }
private CodegenExpression MakeProperties( IDictionary<StatementProperty, object> properties, CodegenMethodScope parent, CodegenClassScope classScope) { if (properties.IsEmpty()) { return StaticMethod(typeof(Collections), "GetEmptyDataMap"); } Func<StatementProperty, CodegenExpression> field = x => EnumValue(typeof(StatementProperty), x.GetName()); Func<object, CodegenExpression> value = Constant; if (properties.Count == 1) { var first = properties.First(); return StaticMethod( typeof(Collections), "SingletonMap", field.Invoke(first.Key), Cast(typeof(object), value.Invoke(first.Value))); } var method = parent.MakeChild( typeof(IDictionary<StatementProperty, object>), typeof(StatementInformationalsCompileTime), classScope); method.Block .DeclareVar<IDictionary<StatementProperty, object>>( "properties", NewInstance(typeof(Dictionary<StatementProperty, object>))); foreach (var entry in properties) { method.Block.ExprDotMethod( Ref("properties"), "Put", field.Invoke(entry.Key), value.Invoke(entry.Value)); } method.Block.MethodReturn(Ref("properties")); return LocalMethod(method); }
public CodegenMethod Codegen( CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(FilterSpecPlanPath), typeof(FilterSpecParamForge), classScope); method.Block.DeclareVar( typeof(FilterSpecPlanPathTriplet[]), "triplets", NewArrayByLength(typeof(FilterSpecPlanPathTriplet), Constant(Triplets.Length))); for (var i = 0; i < Triplets.Length; i++) { var triplet = Triplets[i].Codegen(method, symbols, classScope); method.Block.AssignArrayElement("triplets", Constant(i), LocalMethod(triplet)); } method.Block .DeclareVar<FilterSpecPlanPath>("path", NewInstance(typeof(FilterSpecPlanPath))) .SetProperty(Ref("path"), "Triplets", Ref("triplets")) .SetProperty(Ref("path"), "PathNegate", OptionalEvaluator(PathNegate, method, classScope)) .MethodReturn(Ref("path")); return method; }
private CodegenMethod GetMapCodegen( CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { return codegenMethodScope .MakeChild(typeof(object), GetType(), codegenClassScope) .AddParam(typeof(IDictionary<string, object>), "map") .Block .DeclareVar<object>("value", ExprDotMethod(Ref("map"), "Get", Constant(propertyMap))) .IfRefNullReturnNull("value") .IfInstanceOf("value", typeof(EventBean)) .BlockReturn( mapEntryGetter.EventBeanGetCodegen( CastRef(typeof(EventBean), "value"), codegenMethodScope, codegenClassScope)) .MethodReturn( mapEntryGetter.UnderlyingGetCodegen( CastRef(mapEntryGetter.TargetType, "value"), codegenMethodScope, codegenClassScope)); }
public AggregatorMinMaxEver( AggregationForgeFactoryMinMax factory, int col, CodegenCtor rowCtor, CodegenMemberCol membersColumnized, CodegenClassScope classScope, Type optionalDistinctValueType, DataInputOutputSerdeForge optionalDistinctSerde, bool hasFilter, ExprNode optionalFilter, DataInputOutputSerdeForge serde) : base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter) { _factory = factory; _currentMinMax = membersColumnized.AddMember(col, typeof(IComparable), "currentMinMax"); _serde = classScope.AddOrGetDefaultFieldSharable( new CodegenSharableSerdeClassTyped( CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.VALUE_NULLABLE, factory.ResultType, serde, classScope)); }
public static CodegenExpression Codegen( DTLocalDtxIntervalForge forge, CodegenExpression start, CodegenExpression end, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope .MakeChild(typeof(bool?), typeof(DTLocalDtxIntervalEval), codegenClassScope) .AddParam(typeof(DateTimeEx), "start") .AddParam(typeof(DateTimeEx), "end"); methodNode.Block.MethodReturn( forge.intervalForge.Codegen( ExprDotName(Ref("start"), "UtcMillis"), ExprDotName(Ref("end"), "UtcMillis"), methodNode, exprSymbol, codegenClassScope)); return LocalMethod(methodNode, start, end); }
public static void GetEnumeratorJoinCodegen( ResultSetProcessorSimpleForge forge, CodegenClassScope classScope, CodegenMethod method, CodegenInstanceAux instance) { method.Block.DeclareVar<UniformPair<EventBean[]>>( "result", ExprDotMethod( Ref("this"), "ProcessJoinResult", REF_JOINSET, StaticMethod(typeof(Collections), "GetEmptySet", new[] {typeof(MultiKeyArrayOfKeys<EventBean>)}), ConstantTrue())) .IfRefNull("result") .BlockReturn( StaticMethod(typeof(Collections), "GetEmptyEnumerator", new[] {typeof(EventBean)})) .MethodReturn( ExprDotMethod( StaticMethod(typeof(Arrays), "Enumerate", GetProperty(Ref("result"), "First")), "GetEnumerator")); }
public CodegenExpression Codegen( EnumForgeCodegenParams premade, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { Type arrayType = TypeHelper.GetArrayType(_arrayComponentType); ExprForgeCodegenSymbol scope = new ExprForgeCodegenSymbol(false, null); CodegenMethod methodNode = codegenMethodScope.MakeChildWithScope(arrayType, typeof(EnumArrayOfScalarNoParams), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); CodegenBlock block = methodNode.Block .IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")) .BlockReturn(NewArrayByLength(_arrayComponentType, Constant(0))) .DeclareVar(arrayType, "result", NewArrayByLength(_arrayComponentType, ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"))) .DeclareVar <int>("count", Constant(0)); block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(Ref("result"), Ref("count"), Cast(_arrayComponentType, Ref("next"))) .IncrementRef("count"); block.MethodReturn(Ref("result")); return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx)); }
public override CodegenExpression UnderlyingFragmentCodegen( CodegenExpression underlyingExpression, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { if (FragmentType == null) { return ConstantNull(); } CodegenExpression factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); CodegenExpression eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(FragmentType, EPStatementInitServicesConstants.REF)); return StaticMethod( typeof(JsonFieldGetterHelperSchema), "HandleJsonCreateFragmentArray", underlyingExpression, Constant(Field.PropertyName), eventType, factory); }
public override CodegenExpression UnderlyingFragmentCodegen( CodegenExpression underlyingExpression, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { if (OptionalInnerType == null) { return ConstantNull(); } CodegenExpression factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); CodegenExpression eventType = codegenClassScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen(OptionalInnerType, EPStatementInitServicesConstants.REF)); return StaticMethod( typeof(JsonFieldGetterHelperProvided), "HandleJsonProvidedCreateFragmentIndexed", ExprDotName(underlyingExpression, field.Name), Constant(Index), eventType, factory); }
public override CodegenExpression UnderlyingExistsCodegen( CodegenExpression underlyingExpression, CodegenMethodScope parent, CodegenClassScope codegenClassScope) { CodegenExpression memberCache = codegenClassScope.AddOrGetDefaultFieldSharable(SharableCode); var method = parent.MakeChild(typeof(bool), typeof(DynamicPropertyGetterByMethodOrPropertyBase), codegenClassScope) .AddParam(typeof(object), "@object"); method.Block .DeclareVar <DynamicPropertyDescriptorByMethod>("desc", GetPopulateCacheCodegen(memberCache, Ref("@object"), method, codegenClassScope)) .IfCondition(EqualsNull(ExprDotName(Ref("desc"), "Method"))) .BlockReturn(ConstantFalse()) .MethodReturn( StaticMethod( typeof(DynamicMappedPropertyGetterByMethodOrProperty), "DynamicMappedPropertyExists", Ref("desc"), Ref("@object"), Constant(_parameters[0]))); return(LocalMethod(method, underlyingExpression)); }
public override CodegenExpression Codegen( EnumForgeCodegenParams premade, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var scope = new ExprForgeCodegenSymbol(false, null); var methodNode = codegenMethodScope.MakeChildWithScope(typeof(EventBean), typeof(EnumFirstOfEvent), scope, codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS); var block = methodNode.Block; var forEach = block .ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL) .AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next")); CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass( forEach, InnerExpression.EvaluationType, InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope)); forEach.BlockReturn(Ref("next")); block.MethodReturn(ConstantNull()); return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx)); }
public CodegenExpression EvaluateCodegen( Type requiredType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope.MakeChild( EvaluationType, typeof(ExprEvaluatorStreamDTProp), codegenClassScope); var refEPS = exprSymbol.GetAddEPS(methodNode); methodNode.Block .DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(streamId))) .IfRefNullReturnNull("@event") .MethodReturn( CodegenLegoCast.CastSafeFromObjectType( EvaluationType, getter.EventBeanGetCodegen(Ref("@event"), methodNode, codegenClassScope))); return LocalMethod(methodNode); }
private CodegenMethod NavigateMethodCodegen( CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var navigateRecordMethod = NavigateRecordMethodCodegen(codegenMethodScope, codegenClassScope); return codegenMethodScope.MakeChild(typeof(GenericRecord), GetType(), codegenClassScope) .AddParam(typeof(GenericRecord), "record") .Block .DeclareVar<object>( "value", CodegenExpressionBuilder.StaticMethod( typeof(AvroEventBeanGetterNestedIndexRooted), "GetAtIndex", CodegenExpressionBuilder.Ref("record"), CodegenExpressionBuilder.Constant(_posTop.Name), CodegenExpressionBuilder.Constant(_index))) .IfRefNullReturnNull("value") .MethodReturn( CodegenExpressionBuilder.LocalMethod( navigateRecordMethod, CodegenExpressionBuilder.CastRef(typeof(GenericRecord), "value"))); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { CodegenExpression math = codegenClassScope.AddOrGetDefaultFieldSharable(new MathContextCodegenField(_optionalMathContext)); var method = codegenMethodScope .MakeChild(typeof(decimal?), typeof(EnumAverageScalarForge), codegenClassScope) .AddParam(EnumForgeCodegenNames.PARAMS) .Block .DeclareVar<EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal>( "agg", NewInstance(typeof(EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal), math)) .ForEach(typeof(object), "num", EnumForgeCodegenNames.REF_ENUMCOLL) .IfRefNull("num") .BlockContinue() .Expression(ExprDotMethod(Ref("agg"), "Enter", Ref("num"))) .BlockEnd() .MethodReturn(ExprDotName(Ref("agg"), "Value")); return LocalMethod(method, args.Expressions); }
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); }
private void MakeUnderlyingCodegen( CodegenBlock block, CodegenMethodScope method, CodegenClassScope codegenClassScope) { block .DeclareVar(_jsonEventType.UnderlyingType, "und", Cast(_jsonEventType.UnderlyingType, _beanInstantiator.Make(method, codegenClassScope))) .DeclareVar <object>("value", ConstantNull()); for (var i = 0; i < _writeFieldReflection.Length; i++) { block.AssignRef("value", ArrayAtIndex(Ref("properties"), Constant(i))); var targetType = _writeFieldReflection[i].FieldType; CodegenExpression value; if (targetType.IsPrimitive) { var caster = SimpleTypeCasterFactory.GetCaster(typeof(object), targetType); value = caster.Codegen(Ref("value"), typeof(object), method, codegenClassScope); } else { value = Cast(targetType, Ref("value")); } var set = Assign(ExprDotName(Ref("und"), _writeFieldReflection[i].Name), value); if (_primitiveType[i]) { block.IfRefNotNull("value").Expression(set).BlockEnd(); } else { block.Expression(set); } } block.BlockReturn(Ref("und")); }
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 static CodegenExpression CodegenTypeableSingle( ExprCaseNodeForge forge, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { CodegenMethod methodNode = codegenMethodScope.MakeChild( typeof(object[]), typeof(ExprCaseNodeForgeEvalTypable), codegenClassScope); CodegenBlock block = methodNode.Block .DeclareVar<IDictionary<object, object>>( "map", StaticMethod( typeof(CompatExtensions), "UnwrapDictionary", forge.EvaluateCodegen( typeof(IDictionary<object, object>), methodNode, exprSymbol, codegenClassScope))) .DeclareVar<object[]>( "row", NewArrayByLength(typeof(object), ExprDotName(Ref("map"), "Count"))); int index = -1; foreach (KeyValuePair<string, object> entry in forge.mapResultType) { index++; block.AssignArrayElement( Ref("row"), Constant(index), ExprDotMethod(Ref("map"), "Get", Constant(entry.Key))); } block.MethodReturn(Ref("row")); return LocalMethod(methodNode); }
public CodegenExpression EvaluateMatchesCodegen( CodegenMethodScope parent, ExprSubselectEvalMatchSymbol symbols, CodegenClassScope classScope) { var leftResultType = valueEval.EvaluationType.GetBoxedType(); var method = parent.MakeChild(subselect.EvaluationType, GetType(), classScope); method.Block .ApplyTri( new ReturnIfNoMatch(Constant(resultWhenNoMatchingEvents), Constant(resultWhenNoMatchingEvents)), method, symbols) .DeclareVar( leftResultType, "leftResult", valueEval.EvaluateCodegen(valueEval.EvaluationType, parent, symbols, classScope)) .ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols); var nrSymbols = new SubselectForgeNRSymbol(leftResultType); var child = parent .MakeChildWithScope(subselect.EvaluationType, GetType(), nrSymbols, classScope) .AddParam(leftResultType, NAME_LEFTRESULT) .AddParam(typeof(EventBean[]), NAME_EPS) .AddParam(typeof(bool), NAME_ISNEWDATA) .AddParam(typeof(FlexCollection), NAME_MATCHINGEVENTS) .AddParam(typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT); child.Block.MethodReturn(CodegenEvaluateInternal(child, nrSymbols, classScope)); method.Block.MethodReturn( LocalMethod( child, REF_LEFTRESULT, REF_EVENTS_SHIFTED, symbols.GetAddIsNewData(method), symbols.GetAddMatchingEvents(method), symbols.GetAddExprEvalCtx(method))); return LocalMethod(method); }