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 CodegenMethod CodegenWithEventType( CodegenMethodScope parent, CodegenClassScope classScope) { var symbolsWithType = new SAIFFInitializeSymbolWEventType(); var method = parent.MakeChildWithScope(typeof(FilterSpecPlan), typeof(FilterSpecParamForge), symbolsWithType, classScope) .AddParam(typeof(EventType), SAIFFInitializeSymbolWEventType.REF_EVENTTYPE.Ref) .AddParam(typeof(EPStatementInitServices), SAIFFInitializeSymbol.REF_STMTINITSVC.Ref); if (Paths.Length == 0) { method.Block.MethodReturn(PublicConstValue(typeof(FilterSpecPlan), "EMPTY_PLAN")); return method; } method.Block.DeclareVar<FilterSpecPlanPath[]>("paths", NewArrayByLength(typeof(FilterSpecPlanPath), Constant(Paths.Length))); for (var i = 0; i < Paths.Length; i++) { method.Block.AssignArrayElement("paths", Constant(i), LocalMethod(Paths[i].Codegen(method, symbolsWithType, classScope))); } method.Block .DeclareVar<FilterSpecPlan>("plan", NewInstance(typeof(FilterSpecPlan))) .SetProperty(Ref("plan"), "Paths", Ref("paths")) .SetProperty(Ref("plan"), "FilterConfirm", OptionalEvaluator(FilterConfirm, method, classScope)) .SetProperty(Ref("plan"), "FilterNegate", OptionalEvaluator(FilterNegate, method, classScope)) .SetProperty(Ref("plan"), "Convertor", ConvertorForge == null ? ConstantNull() : ConvertorForge.MakeAnonymous(method, classScope)) .ExprDotMethod(Ref("plan"), "Initialize") .MethodReturn(Ref("plan")); return method; }
public override CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols) { var method = parent.MakeChild( typeof(FilterSpecParamAdvancedIndexQuadTreePointRegion), GetType(), classScope); method.Block .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(lookupable.MakeCodegen(method, symbols, classScope))) .DeclareVar<FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName())) .DeclareVar<FilterSpecParamAdvancedIndexQuadTreePointRegion>( "fpai", NewInstance<FilterSpecParamAdvancedIndexQuadTreePointRegion>(Ref("lookupable"), Ref("filterOperator"))) .SetProperty( Ref("fpai"), "XEval", FilterSpecParamFilterForEvalDoubleForgeHelper.MakeAnonymous(_xEval, GetType(), classScope, method)) .SetProperty( Ref("fpai"), "YEval", FilterSpecParamFilterForEvalDoubleForgeHelper.MakeAnonymous(_yEval, GetType(), classScope, method)) .MethodReturn(Ref("fpai")); 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(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 override CodegenMethod MakeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols, CodegenClassScope classScope) { var method = parent.MakeChild( typeof(FilterSpecLookupableAdvancedIndex), typeof(FilterSpecLookupableAdvancedIndexForge), classScope); Func<EventPropertyGetterSPI, CodegenExpression> toEval = getter => EventTypeUtility.CodegenGetterWCoerce(getter, typeof(double?), null, method, GetType(), classScope); method.Block .DeclareVar<FilterSpecLookupableAdvancedIndex>( "lookupable", NewInstance<FilterSpecLookupableAdvancedIndex>( Constant(Expression), ConstantNull(), Typeof(ReturnType))) .SetProperty(Ref("lookupable"), "QuadTreeConfig", QuadTreeConfig.Make()) .SetProperty(Ref("lookupable"), "X", toEval.Invoke(_x)) .SetProperty(Ref("lookupable"), "Y", toEval.Invoke(_y)) .SetProperty(Ref("lookupable"), "Width", toEval.Invoke(_width)) .SetProperty(Ref("lookupable"), "Height", toEval.Invoke(_height)) .SetProperty(Ref("lookupable"), "IndexType", Constant(IndexType)) .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 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 CodegenMethod Codegen( CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(FilterSpecPlanPathTriplet), typeof(FilterSpecParamForge), classScope); method.Block .DeclareVar<FilterSpecPlanPathTriplet>("triplet", NewInstance(typeof(FilterSpecPlanPathTriplet))) .SetProperty(Ref("triplet"), "Param", LocalMethod(Param.MakeCodegen(classScope, method, symbols))) .SetProperty(Ref("triplet"), "TripletConfirm", OptionalEvaluator(TripletConfirm, method, classScope)) .MethodReturn(Ref("triplet")); 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 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 MakeCodegen( CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { var method = parent.MakeChild(typeof(ContextControllerDetailHashItem), GetType(), classScope); method.Block.DeclareVar<EventType>( "eventType", EventTypeUtility.ResolveTypeCodegen( FilterSpecCompiled.FilterForEventType, symbols.GetAddInitSvc(method))); var symbolsWithType = new SAIFFInitializeSymbolWEventType(); var methodLookupableMake = parent.MakeChildWithScope( typeof(ExprFilterSpecLookupable), GetType(), symbolsWithType, classScope) .AddParam(typeof(EventType), "eventType") .AddParam(typeof(EPStatementInitServices), SAIFFInitializeSymbol.REF_STMTINITSVC.Ref); var methodLookupable = Lookupable.MakeCodegen(methodLookupableMake, symbolsWithType, classScope); methodLookupableMake.Block.MethodReturn(LocalMethod(methodLookupable)); method.Block .DeclareVar<ContextControllerDetailHashItem>( "item", NewInstance(typeof(ContextControllerDetailHashItem))) .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(methodLookupableMake, Ref("eventType"), symbols.GetAddInitSvc(method))) .SetProperty( Ref("item"), "FilterSpecActivatable", LocalMethod(FilterSpecCompiled.MakeCodegen(method, symbols, classScope))) .SetProperty(Ref("item"), "Lookupable", Ref("lookupable")) .Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY) .Add("RegisterLookupable", Ref("eventType"), Ref("lookupable"))) .MethodReturn(Ref("item")); return LocalMethod(method); }
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 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; }
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 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) { if (FilterBoolExprId == -1) { throw new IllegalStateException("Unassigned filter boolean expression path num"); } var method = parent.MakeChild(typeof(FilterSpecParamExprNode), GetType(), classScope); method.Block .DeclareVar<ExprFilterSpecLookupable>( "lookupable", LocalMethod(lookupable.MakeCodegen(method, symbols, classScope))) .DeclareVar<FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName())); // getFilterValue-FilterSpecParamExprNode code //var param = NewAnonymousClass( // method.Block, // typeof(FilterSpecParamExprNode), // Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator"))); //var getFilterValue = CodegenMethod.MakeMethod(typeof(object), GetType(), classScope) // .AddParam(GET_FILTER_VALUE_FP); //param.AddMethod("GetFilterValue", getFilterValue); var getFilterValue = new CodegenExpressionLambda(method.Block) .WithParams(GET_FILTER_VALUE_FP); var param = NewInstance<ProxyFilterSpecParamExprNode>( Ref("lookupable"), Ref("filterOperator")); if (TaggedEventTypes != null && !TaggedEventTypes.IsEmpty() || _arrayEventTypes != null && !_arrayEventTypes.IsEmpty()) { var size = TaggedEventTypes?.Count ?? 0; size += _arrayEventTypes?.Count ?? 0; getFilterValue.Block.DeclareVar<EventBean[]>( "events", NewArrayByLength(typeof(EventBean), Constant(size + 1))); var count = 1; if (TaggedEventTypes != null) { foreach (var tag in TaggedEventTypes.Keys) { getFilterValue.Block.AssignArrayElement( "events", Constant(count), ExprDotMethod(REF_MATCHEDEVENTMAP, "GetMatchingEventByTag", Constant(tag))); count++; } } if (_arrayEventTypes != null) { foreach (var entry in _arrayEventTypes) { var compositeEventType = entry.Value.First; var compositeEventTypeMember = classScope.AddDefaultFieldUnshared( true, typeof(EventType), EventTypeUtility.ResolveTypeCodegen( compositeEventType, EPStatementInitServicesConstants.REF)); var factory = classScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); var matchingAsMap = ExprDotName(REF_MATCHEDEVENTMAP, "MatchingEventsAsMap"); var mapBean = ExprDotMethod( factory, "AdapterForTypedMap", matchingAsMap, compositeEventTypeMember); getFilterValue.Block.AssignArrayElement("events", Constant(count), mapBean); count++; } } } else { getFilterValue.Block.DeclareVar<EventBean[]>("events", ConstantNull()); } getFilterValue.Block .DeclareVar<object>( "value", ExprDotMethod( ExprDotName(Ref("node"), "FilterBooleanExpressionFactory"), "Make", Ref("node"), // FilterSpecParamExprNode filterSpecParamExprNode Ref("events"), // EventBean[] events REF_EXPREVALCONTEXT, // ExprEvaluatorContext exprEvaluatorContext ExprDotName(REF_EXPREVALCONTEXT, "AgentInstanceId"), // int agentInstanceId REF_STMTCTXFILTEREVALENV)) .BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("value"))); // expression evaluator var evaluator = ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce( ExprNode.Forge, method, GetType(), classScope); // setter calls method.Block .DeclareVar<ProxyFilterSpecParamExprNode>("node", param) .SetProperty(Ref("node"), "ProcGetFilterValue", getFilterValue) .SetProperty(Ref("node"), "ExprText", Constant( StringValue.StringDelimitedTo60Char( ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(ExprNode)))) .SetProperty(Ref("node"), "ExprNode", evaluator) .SetProperty(Ref("node"), "HasVariable", Constant(_hasVariable)) .SetProperty(Ref("node"), "HasFilterStreamSubquery", Constant(_hasFilterStreamSubquery)) .SetProperty(Ref("node"), "FilterBoolExprId", Constant(FilterBoolExprId)) .SetProperty(Ref("node"), "HasTableAccess", Constant(_hasTableAccess)) .SetProperty( Ref("node"), "FilterBooleanExpressionFactory", ExprDotName( symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.FILTERBOOLEANEXPRESSIONFACTORY)) .SetProperty( Ref("node"), "UseLargeThreadingProfile", Constant( _compileTimeServices.Configuration.Common.Execution.ThreadingProfile == ThreadingProfile.LARGE)); if (TaggedEventTypes != null && !TaggedEventTypes.IsEmpty() || _arrayEventTypes != null && !_arrayEventTypes.IsEmpty()) { var size = TaggedEventTypes != null ? TaggedEventTypes.Count : 0; size += _arrayEventTypes != null ? _arrayEventTypes.Count : 0; method.Block.DeclareVar<EventType[]>( "providedTypes", NewArrayByLength(typeof(EventType), Constant(size + 1))); for (var i = 1; i < _streamTypeService.StreamNames.Length; i++) { var tag = _streamTypeService.StreamNames[i]; var eventType = FindMayNull(tag, TaggedEventTypes); if (eventType == null) { eventType = FindMayNull(tag, _arrayEventTypes); } if (eventType == null) { throw new IllegalStateException("Failed to find event type for tag '" + tag + "'"); } method.Block.AssignArrayElement( "providedTypes", Constant(i), EventTypeUtility.ResolveTypeCodegen(eventType, EPStatementInitServicesConstants.REF)); // note: we leave index zero at null as that is the current event itself } method.Block.SetProperty(Ref("node"), "EventTypesProvidedBy", Ref("providedTypes")); } // register boolean expression so it can be found method.Block.Expression( ExprDotMethodChain(symbols.GetAddInitSvc(method)) .Get(EPStatementInitServicesConstants.FILTERSHAREDBOOLEXPRREGISTERY) .Add("RegisterBoolExpr", Ref("node"))); method.Block.MethodReturn(Ref("node")); return method; }
public abstract CodegenMethod MakeCodegen( CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbolWEventType symbols);
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 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); CodegenExpression filterForValue; if (_inListConstantsOnly != null) { filterForValue = NewInstance<HashableMultiKey>(Constant(_inListConstantsOnly)); } else if (!_hasCollMapOrArray) { getFilterValue.Block.DeclareVar<object[]>( "values", NewArrayByLength(typeof(object), Constant(_listOfValues.Count))); for (var i = 0; i < _listOfValues.Count; i++) { var forge = _listOfValues[i]; getFilterValue.Block.AssignArrayElement( Ref("values"), Constant(i), forge.MakeCodegen(classScope, method)); } filterForValue = NewInstance<HashableMultiKey>(Ref("values")); } else { getFilterValue.Block.DeclareVar<ArrayDeque<object>>( "values", NewInstance<ArrayDeque<object>>(Constant(_listOfValues.Count))); for (var i = 0; i < _listOfValues.Count; i++) { var valueName = "value" + i; var adderName = "adder" + i; getFilterValue.Block .DeclareVar<object>(valueName, _listOfValues[i].MakeCodegen(classScope, parent)) .IfRefNotNull(valueName) .DeclareVar(_adders[i].GetType(), adderName, EnumValue(_adders[i].GetType(), "INSTANCE")) .ExprDotMethod(Ref(adderName), "Add", Ref("values"), Ref(valueName)) .BlockEnd(); } filterForValue = NewInstance<HashableMultiKey>(ExprDotMethod(Ref("values"), "ToArray")); } getFilterValue.Block .DeclareVar<object>("val", filterForValue) .BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("val"))); method.Block.MethodReturn(param); return method; }