public IEnumerator <EventBean> GetEnumerator(Viewable parent)
{
if (!_prototype.IsHistoricalOnly)
{
return(ObtainEnumerator(parent));
}
ResultSetProcessorUtil.ClearAndAggregateUngrouped(_exprEvaluatorContext, _aggregationService, parent);
ArrayDeque <EventBean> deque = ResultSetProcessorUtil.EnumeratorToDeque(ObtainEnumerator(parent));
_aggregationService.ClearResults(_exprEvaluatorContext);
return(deque.GetEnumerator());
}
public IEnumerator <EventBean> GetEnumerator(Viewable parent)
{
if (!Prototype.IsHistoricalOnly)
{
return(ObtainEnumerator());
}
ResultSetProcessorUtil.ClearAndAggregateUngrouped(ExprEvaluatorContext, AggregationService, parent);
var enumerator = ObtainEnumerator();
AggregationService.ClearResults(ExprEvaluatorContext);
return(enumerator);
}
public override void Evaluate(
EventBean[] eventsPerStream,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext)
{
AggregationService.ClearResults(exprEvaluatorContext);
if (matchingEvents == null)
{
return;
}
var events = new EventBean[eventsPerStream.Length + 1];
Array.Copy(eventsPerStream, 0, events, 1, eventsPerStream.Length);
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
foreach (EventBean subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = (bool?)FilterExpr.Evaluate(evaluateParams);
if (pass ?? false)
{
AggregationService.ApplyEnter(events, null, exprEvaluatorContext);
}
}
}
public override void Evaluate(
EventBean[] eventsPerStream,
ICollection<EventBean> matchingEvents,
ExprEvaluatorContext exprEvaluatorContext)
{
AggregationService.ClearResults(exprEvaluatorContext);
if (matchingEvents == null)
{
return;
}
var events = new EventBean[eventsPerStream.Length + 1];
Array.Copy(eventsPerStream, 0, events, 1, eventsPerStream.Length);
var evaluateParams = new EvaluateParams(events, true, exprEvaluatorContext);
foreach (EventBean subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = FilterEval.Evaluate(evaluateParams);
if (true.Equals(pass))
{
Object groupKey = GenerateGroupKey(events, true, exprEvaluatorContext);
AggregationService.ApplyEnter(events, groupKey, exprEvaluatorContext);
}
}
}
public static void ClearAndAggregateUngrouped(ExprEvaluatorContext exprEvaluatorContext, AggregationService aggregationService, Viewable parent)
{
aggregationService.ClearResults(exprEvaluatorContext);
var ee = parent.GetEnumerator();
var eventsPerStream = new EventBean[1];
while (ee.MoveNext())
{
eventsPerStream[0] = ee.Current;
aggregationService.ApplyEnter(eventsPerStream, null, exprEvaluatorContext);
}
}
// Called based on schedule evaluation registered when a variable changes (new data is null).
// Called when new data arrives.
private void Expire(EventBean[] newData, EventBean[] oldData)
{
OneEventCollection expired = null;
if (oldData != null)
{
expired = new OneEventCollection();
expired.Add(oldData);
}
int expiredCount = 0;
if (!_window.IsEmpty())
{
ExpressionWindowTimestampEventPair newest = _window.Last;
while (true)
{
ExpressionWindowTimestampEventPair first = _window.First;
bool pass = CheckEvent(first, newest, expiredCount);
if (!pass)
{
if (expired == null)
{
expired = new OneEventCollection();
}
EventBean removed = _window.RemoveFirst().TheEvent;
expired.Add(removed);
if (AggregationService != null)
{
_removedEvents[0] = removed;
AggregationService.ApplyLeave(_removedEvents, null, AgentInstanceContext);
}
expiredCount++;
InternalHandleExpired(first);
}
else
{
break;
}
if (_window.IsEmpty())
{
if (AggregationService != null)
{
AggregationService.ClearResults(AgentInstanceContext);
}
break;
}
}
}
// Check for any events that get pushed out of the window
EventBean[] expiredArr = null;
if (expired != null)
{
expiredArr = expired.ToArray();
}
// update event buffer for access by expressions, if any
if (ViewUpdatedCollection != null)
{
ViewUpdatedCollection.Update(newData, expiredArr);
}
// If there are child views, call update method
if (HasViews)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _dataWindowViewFactory.ViewName, newData, expiredArr);
}
UpdateChildren(newData, expiredArr);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
}
public void ClearResults(ExprEvaluatorContext exprEvaluatorContext)
{
_service.ClearResults(exprEvaluatorContext);
}
// Called based on schedule evaluation registered when a variable changes (new data is null).
// Called when new data arrives.
public void Expire(int numEventsInBatch)
{
if (numEventsInBatch == Window.Count || numEventsInBatch == -1)
{
var batchNewData = Window.ToArray();
if (ViewUpdatedCollection != null)
{
ViewUpdatedCollection.Update(batchNewData, LastBatch);
}
// post
if (batchNewData != null || LastBatch != null)
{
Instrument.With(
i => i.QViewIndicate(this, _dataWindowViewFactory.ViewName, batchNewData, LastBatch),
i => i.AViewIndicate(),
() => UpdateChildren(batchNewData, LastBatch));
}
// clear
Window.Clear();
LastBatch = batchNewData;
if (AggregationService != null)
{
AggregationService.ClearResults(AgentInstanceContext);
}
OldestEvent = null;
NewestEvent = null;
}
else
{
var batchNewData = Window.Take(numEventsInBatch).ToArray();
unchecked
{
for (int ii = 0; ii < batchNewData.Length; ii++)
{
Window.Remove(batchNewData[ii]);
}
}
if (ViewUpdatedCollection != null)
{
ViewUpdatedCollection.Update(batchNewData, LastBatch);
}
// post
if (batchNewData != null || LastBatch != null)
{
Instrument.With(
i => i.QViewIndicate(this, _dataWindowViewFactory.ViewName, batchNewData, LastBatch),
i => i.AViewIndicate(),
() => UpdateChildren(batchNewData, LastBatch));
}
// clear
LastBatch = batchNewData;
if (AggregationService != null)
{
AggregationService.ApplyLeave(batchNewData, null, AgentInstanceContext);
}
OldestEvent = Window.FirstOrDefault();
}
}
