public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
if (overlaps)
{
long minThreshold = minEval.Evaluate(leftStart, eventsPerStream, newData, context);
long maxThreshold = maxEval.Evaluate(leftEnd, eventsPerStream, newData, context);
return(IntervalComputerOverlapsAndByThresholdEval.ComputeIntervalOverlaps(
leftStart,
leftEnd,
rightStart,
rightEnd,
minThreshold,
maxThreshold));
}
else
{
long minThreshold = minEval.Evaluate(rightStart, eventsPerStream, newData, context);
long maxThreshold = maxEval.Evaluate(rightEnd, eventsPerStream, newData, context);
return(IntervalComputerOverlapsAndByThresholdEval.ComputeIntervalOverlaps(
rightStart,
rightEnd,
leftStart,
leftEnd,
minThreshold,
maxThreshold));
}
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
var threshold = _thresholdExpr.Evaluate(Math.Min(rightEnd, leftEnd), eventsPerStream, newData, context);
if (threshold < 0)
{
Log.Warn("The 'finishes' date-time method does not allow negative threshold");
return(null);
}
if (leftStart >= rightStart)
{
return(false);
}
var delta = Math.Abs(leftEnd - rightEnd);
return(delta <= threshold);
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
var minStart = _minStartEval.Evaluate(rightStart, eventsPerStream, newData, context);
var maxStart = _maxStartEval.Evaluate(rightStart, eventsPerStream, newData, context);
var minEnd = _minEndEval.Evaluate(rightEnd, eventsPerStream, newData, context);
var maxEnd = _maxEndEval.Evaluate(rightEnd, eventsPerStream, newData, context);
if (_during)
{
return(IntervalComputerDuringAndIncludesMinMax.ComputeInternalDuring(
leftStart, leftEnd, rightStart, rightEnd, minStart, maxStart, minEnd, maxEnd));
}
else
{
return(IntervalComputerDuringAndIncludesMinMax.ComputeInternalIncludes(
leftStart, leftEnd, rightStart, rightEnd, minStart, maxStart, minEnd, maxEnd));
}
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
var thresholdValue = _threshold.Evaluate(leftStart, eventsPerStream, newData, context);
if (_during)
{
var deltaStart = leftStart - rightStart;
if (deltaStart <= 0 || deltaStart > thresholdValue)
{
return(false);
}
var deltaEnd = rightEnd - leftEnd;
return(!(deltaEnd <= 0 || deltaEnd > thresholdValue));
}
else
{
var deltaStart = rightStart - leftStart;
if (deltaStart <= 0 || deltaStart > thresholdValue)
{
return(false);
}
var deltaEnd = leftEnd - rightEnd;
return(!(deltaEnd <= 0 || deltaEnd > thresholdValue));
}
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
long startValue = start.Evaluate(Math.Min(leftStart, rightStart), eventsPerStream, newData, context);
long endValue = finish.Evaluate(Math.Min(leftEnd, rightEnd), eventsPerStream, newData, context);
if (startValue < 0 || endValue < 0)
{
Log.Warn("The coincides date-time method does not allow negative start and end values");
return(null);
}
return(IntervalComputerConstantCoincides.ComputeIntervalCoincides(
leftStart,
leftEnd,
rightStart,
rightEnd,
startValue,
endValue));
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
long threshold = thresholdExpr.Evaluate(
Math.Min(leftStart, rightStart),
eventsPerStream,
newData,
context);
if (threshold < 0)
{
LogWarningIntervalStartsThreshold();
return(null);
}
var delta = Math.Abs(leftStart - rightStart);
return(delta <= threshold && leftEnd < rightEnd);
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
long threshold = thresholdExpr.Evaluate(Math.Min(rightEnd, leftEnd), eventsPerStream, newData, context);
if (threshold < 0)
{
LogWarningIntervalFinishedByThreshold();
return(null);
}
if (leftStart >= rightStart)
{
return(false);
}
var delta = Math.Abs(leftEnd - rightEnd);
return(delta <= threshold);
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
long rangeStartDelta = start.Evaluate(rightStart, eventsPerStream, newData, context);
long rangeEndDelta = finish.Evaluate(rightStart, eventsPerStream, newData, context);
if (rangeStartDelta > rangeEndDelta)
{
return(IntervalComputerConstantAfter.ComputeIntervalAfter(
leftStart,
rightEnd,
rangeEndDelta,
rangeStartDelta));
}
return(IntervalComputerConstantAfter.ComputeIntervalAfter(
leftStart,
rightEnd,
rangeStartDelta,
rangeEndDelta));
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
if (_overlaps)
{
var threshold = _thresholdExpr.Evaluate(leftStart, eventsPerStream, newData, context);
return(ComputeInternalOverlaps(leftStart, leftEnd, rightStart, rightEnd, 0, threshold));
}
else
{
var threshold = _thresholdExpr.Evaluate(rightStart, eventsPerStream, newData, context);
return(ComputeInternalOverlaps(rightStart, rightEnd, leftStart, leftEnd, 0, threshold));
}
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
long min = minEval.Evaluate(leftStart, eventsPerStream, newData, context);
long max = maxEval.Evaluate(rightEnd, eventsPerStream, newData, context);
if (during)
{
return(ComputeIntervalDuring(leftStart, leftEnd, rightStart, rightEnd, min, max, min, max));
}
return(ComputeIntervalIncludes(leftStart, leftEnd, rightStart, rightEnd, min, max, min, max));
}
public bool?Compute(
long leftStart,
long leftEnd,
long rightStart,
long rightEnd,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext context)
{
var rangeStartDelta = _start.Evaluate(leftEnd, eventsPerStream, newData, context);
var rangeEndDelta = _finish.Evaluate(leftEnd, eventsPerStream, newData, context);
if (rangeStartDelta > rangeEndDelta)
{
return(IntervalComputerConstantBefore.ComputeInternal(
leftStart, leftEnd, rightStart, rangeEndDelta, rangeStartDelta));
}
else
{
return(IntervalComputerConstantBefore.ComputeInternal(
leftStart, leftEnd, rightStart, rangeStartDelta, rangeEndDelta));
}
}
