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( 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 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 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 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 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 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; }
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; }