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