public static CodegenExpression Codegen(
IntervalComputerOverlapsAndByThreshold forge,
CodegenExpression leftStart,
CodegenExpression leftEnd,
CodegenExpression rightStart,
CodegenExpression rightEnd,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(bool),
typeof(IntervalComputerOverlapsAndByThresholdEval),
codegenClassScope)
.AddParam(IntervalForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar <long>(
"threshold",
forge.thresholdExpr.Codegen(
forge.overlaps
? IntervalForgeCodegenNames.REF_LEFTSTART
: IntervalForgeCodegenNames.REF_RIGHTSTART,
methodNode,
exprSymbol,
codegenClassScope));
if (forge.overlaps)
{
block.MethodReturn(
CodegenExpressionBuilder.StaticMethod(
typeof(IntervalComputerOverlapsAndByThresholdEval),
"ComputeIntervalOverlaps",
IntervalForgeCodegenNames.REF_LEFTSTART,
IntervalForgeCodegenNames.REF_LEFTEND,
IntervalForgeCodegenNames.REF_RIGHTSTART,
IntervalForgeCodegenNames.REF_RIGHTEND,
CodegenExpressionBuilder.Constant(0),
CodegenExpressionBuilder.Ref("threshold")));
}
else
{
block.MethodReturn(
CodegenExpressionBuilder.StaticMethod(
typeof(IntervalComputerOverlapsAndByThresholdEval),
"ComputeIntervalOverlaps",
IntervalForgeCodegenNames.REF_RIGHTSTART,
IntervalForgeCodegenNames.REF_RIGHTEND,
IntervalForgeCodegenNames.REF_LEFTSTART,
IntervalForgeCodegenNames.REF_LEFTEND,
CodegenExpressionBuilder.Constant(0),
CodegenExpressionBuilder.Ref("threshold")));
}
return(CodegenExpressionBuilder.LocalMethod(methodNode, leftStart, leftEnd, rightStart, rightEnd));
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
if (_overlaps)
{
var minThreshold = _minEval.Evaluate(leftStart, eventsPerStream, newData, context);
var maxThreshold = _maxEval.Evaluate(leftEnd, eventsPerStream, newData, context);
return(IntervalComputerOverlapsAndByThreshold.ComputeInternalOverlaps(
leftStart, leftEnd, rightStart, rightEnd, minThreshold, maxThreshold));
}
else
{
var minThreshold = _minEval.Evaluate(rightStart, eventsPerStream, newData, context);
var maxThreshold = _maxEval.Evaluate(rightEnd, eventsPerStream, newData, context);
return(IntervalComputerOverlapsAndByThreshold.ComputeInternalOverlaps(
rightStart, rightEnd, leftStart, leftEnd, minThreshold, maxThreshold));
}
}
