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