public void TestFlatten()
{
// test many arrays
var testEvents = MakeEventArray(new[] { "a1", "a2", "b1", "b2", "b3", "c1", "c2" });
var eventVector = new ArrayDeque <EventBean[]>();
eventVector.Add(new[] { testEvents[0], testEvents[1] });
eventVector.Add(new[] { testEvents[2] });
eventVector.Add(new[] { testEvents[3], testEvents[4], testEvents[5] });
eventVector.Add(new[] { testEvents[6] });
var events = EventBeanUtility.Flatten(eventVector);
Assert.AreEqual(7, events.Length);
for (var i = 0; i < testEvents.Length; i++)
{
Assert.AreEqual(events[i], testEvents[i]);
}
// test just one array
eventVector.Clear();
eventVector.Add(new[] { testEvents[2] });
events = EventBeanUtility.Flatten(eventVector);
Assert.AreEqual(events[0], testEvents[2]);
// test empty vector
eventVector.Clear();
events = EventBeanUtility.Flatten(eventVector);
Assert.IsNull(events);
}
public void TestEmptyListFront()
{
var testWindow = new ArrayDeque <TimeWindowPair>();
var list1 = new ArrayDeque <EventBean>();
AddToWindow(testWindow, 10L, list1);
var list2 = new ArrayDeque <EventBean>();
list2.Add(events.Get("a"));
AddToWindow(testWindow, 15L, list2);
var list3 = new ArrayDeque <EventBean>();
list3.Add(events.Get("c"));
list3.Add(events.Get("d"));
AddToWindow(testWindow, 20L, list3);
var list4 = new ArrayDeque <EventBean>();
list4.Add(events.Get("e"));
AddToWindow(testWindow, 40L, list4);
IEnumerator <EventBean> enumerator = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(new object[] {
events.Get("a"), events.Get("c"), events.Get("d"), events.Get("e")
}, enumerator);
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
var sort = new OrderedDictionary<object, object>();
var hasColl = false;
var beans = (ICollection<EventBean>) enumcoll;
foreach (var next in beans) {
eventsLambda[_forge.StreamNumLambda] = next;
var comparable = (IComparable) _innerExpression.Evaluate(eventsLambda, isNewData, context);
var entry = sort.Get(comparable);
if (entry == null) {
sort.Put(comparable, next);
continue;
}
if (entry is ICollection<EventBean>) {
((ICollection<EventBean>) entry).Add(next);
continue;
}
Deque<object> coll = new ArrayDeque<object>(2);
coll.Add(entry);
coll.Add(next);
sort.Put(comparable, coll);
hasColl = true;
}
return EnumOrderBySortEval(sort, hasColl, _forge.descending);
}
protected void ReferenceAdd(
EventBean theEvent,
EventBean[] eventsPerStream,
ExprEvaluatorContext exprEvaluatorContext)
{
if (ReferenceEvent(theEvent))
{
var comparable = GetComparable(Spec.Criteria, eventsPerStream, true, exprEvaluatorContext);
var existing = Sorted.Get(comparable);
if (existing == null)
{
Sorted.Put(comparable, theEvent);
}
else if (existing is EventBean eventBean)
{
var coll = new ArrayDeque <EventBean>(2);
coll.Add(eventBean);
coll.Add(theEvent);
Sorted.Put(comparable, coll);
}
else
{
var arrayDeque = (ArrayDeque <EventBean>)existing;
arrayDeque.Add(theEvent);
}
Size++;
}
}
public ICollection<object> EvaluateGetROCollectionScalar(
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext context)
{
if (_forge.ForgeRenderableArray.ChildNodes.Length == 0) {
return Collections.GetEmptyList<object>();
}
var resultList = new ArrayDeque<object>(_evaluators.Length);
foreach (var child in _evaluators) {
var result = child.Evaluate(eventsPerStream, isNewData, context);
if (result != null) {
if (_forge.IsMustCoerce) {
var coercedResult = _forge.Coercer.CoerceBoxed(result);
resultList.Add(coercedResult);
}
else {
resultList.Add(result);
}
}
}
return resultList;
}
public void TestArrayLast()
{
var deque = new ArrayDeque <int>();
Assert.That(deque.Count, Is.EqualTo(0));
deque.Add(1);
Assert.That(deque.Count, Is.EqualTo(1));
Assert.That(deque.Last, Is.EqualTo(1));
deque.Add(2);
Assert.That(deque.Count, Is.EqualTo(2));
Assert.That(deque.Last, Is.EqualTo(2));
deque.Add(3);
Assert.That(deque.Count, Is.EqualTo(3));
Assert.That(deque.Last, Is.EqualTo(3));
deque.Add(4);
Assert.That(deque.Count, Is.EqualTo(4));
Assert.That(deque.Last, Is.EqualTo(4));
Assert.That(deque.RemoveFirst(), Is.EqualTo(1));
Assert.That(deque.Count, Is.EqualTo(3));
Assert.That(deque.Last, Is.EqualTo(4));
Assert.That(deque.RemoveLast(), Is.EqualTo(4));
Assert.That(deque.Count, Is.EqualTo(2));
Assert.That(deque.Last, Is.EqualTo(3));
}
public static IEnumerator<EventBean> For(
IEnumerator<EventBean> sourceIterator,
EventPropertyValueGetter distinctKeyGetter)
{
if (sourceIterator != null && sourceIterator.MoveNext()) {
// there is at least one event...
var first = sourceIterator.Current;
// but is there only one event?
if (!sourceIterator.MoveNext()) {
return EnumerationHelper.Singleton(first);
}
// build distinct set because there are multiple events
var events = new ArrayDeque<EventBean>();
events.Add(first);
events.Add(sourceIterator.Current);
while (sourceIterator.MoveNext()) {
events.Add(sourceIterator.Current);
}
// Determine the reader that we need to use for this use case
var unique = EventBeanUtility.GetDistinctByProp(events, distinctKeyGetter);
return unique.GetEnumerator();
}
return EnumerationHelper.Empty<EventBean>();
}
public void TestObjectAndNull()
{
var testWindow = new ArrayDeque <TimeWindowPair>();
var list1 = new ArrayDeque <EventBean>();
list1.Add(events.Get("c"));
list1.Add(events.Get("d"));
AddToWindow(testWindow, 10L, list1);
AddToWindow(testWindow, 20L, events.Get("a"));
AddToWindow(testWindow, 30L, null);
var list3 = new ArrayDeque <EventBean>();
list3.Add(events.Get("e"));
AddToWindow(testWindow, 40L, list3);
IEnumerator <EventBean> enumerator = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(new object[] {
events.Get("c"), events.Get("d"), events.Get("a"), events.Get("e")
}, enumerator);
}
public void TestFlattenList()
{
// test many arrays
var testEvents = MakeEventArray(new[] { "a1", "a2", "b1", "b2", "b3", "c1", "c2" });
var eventVector = new ArrayDeque <UniformPair <EventBean[]> >();
eventVector.Add(new UniformPair <EventBean[]>(null, new[] { testEvents[0], testEvents[1] }));
eventVector.Add(new UniformPair <EventBean[]>(new[] { testEvents[2] }, null));
eventVector.Add(new UniformPair <EventBean[]>(null, new[] { testEvents[3], testEvents[4], testEvents[5] }));
eventVector.Add(new UniformPair <EventBean[]>(new[] { testEvents[6] }, null));
var events = EventBeanUtility.FlattenList(eventVector);
EPAssertionUtil.AssertEqualsExactOrder(new[] { testEvents[2], testEvents[6] }, events.First);
EPAssertionUtil.AssertEqualsExactOrder(new[] { testEvents[0], testEvents[1], testEvents[3], testEvents[4], testEvents[5] }, events.Second);
// test just one array
eventVector.Clear();
eventVector.Add(new UniformPair <EventBean[]>(new[] { testEvents[2] }, null));
events = EventBeanUtility.FlattenList(eventVector);
EPAssertionUtil.AssertEqualsExactOrder(new[] { testEvents[2] }, events.First);
EPAssertionUtil.AssertEqualsExactOrder((object[])null, events.Second);
// test empty vector
eventVector.Clear();
events = EventBeanUtility.FlattenList(eventVector);
Assert.IsNull(events);
}
public void TestEmptyListSprinkle()
{
var testWindow = new ArrayDeque <TimeWindowPair>();
var list1 = new ArrayDeque <EventBean>();
list1.Add(_events.Get("a"));
AddToWindow(testWindow, 10L, list1);
var list2 = new ArrayDeque <EventBean>();
AddToWindow(testWindow, 15L, list2);
var list3 = new ArrayDeque <EventBean>();
list3.Add(_events.Get("c"));
list3.Add(_events.Get("d"));
AddToWindow(testWindow, 20L, list3);
var list4 = new ArrayDeque <EventBean>();
AddToWindow(testWindow, 40L, list4);
var it = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(new object[] { _events.Get("a"), _events.Get("c"), _events.Get("d") }, it);
}
/// <summary>Adds event to the time window for the specified timestamp. </summary>
/// <param name="timestamp">the time slot for the event</param>
/// <param name="bean">event to add</param>
public void Add(long timestamp, EventBean bean)
{
// Empty window
if (_window.IsEmpty())
{
var pairX = new TimeWindowPair(timestamp, bean);
_window.Add(pairX);
if (_reverseIndex != null)
{
_reverseIndex[bean] = pairX;
}
_size = 1;
return;
}
TimeWindowPair lastPair = _window.Last;
// Windows last timestamp matches the one supplied
if (lastPair.Timestamp == timestamp)
{
if (lastPair.EventHolder is IList <EventBean> )
{
var list = (IList <EventBean>)lastPair.EventHolder;
list.Add(bean);
}
else if (lastPair.EventHolder == null)
{
lastPair.EventHolder = bean;
}
else
{
var existing = (EventBean)lastPair.EventHolder;
IList <EventBean> list = new List <EventBean>(4);
list.Add(existing);
list.Add(bean);
lastPair.EventHolder = list;
}
if (_reverseIndex != null)
{
_reverseIndex[bean] = lastPair;
}
_size++;
return;
}
// Append to window
var pair = new TimeWindowPair(timestamp, bean);
if (_reverseIndex != null)
{
_reverseIndex[bean] = pair;
}
_window.Add(pair);
_size++;
}
public void TestTwoInOneEntryElement()
{
var testWindow = new ArrayDeque <TimeWindowPair>();
var list = new ArrayDeque <EventBean>();
list.Add(_events.Get("a"));
list.Add(_events.Get("b"));
AddToWindow(testWindow, 10L, list);
IEnumerator <EventBean> it = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(new EventBean[] { _events.Get("a"), _events.Get("b") }, it);
}
public override ICollection<EventBean> EvaluateGetCollEvents(
EventBean[] eventsPerStream,
bool newData,
ICollection<EventBean> matchingEvents,
ExprEvaluatorContext context,
ExprSubselectRowNode parent)
{
AggregationService aggregationService =
parent.SubselectAggregationService.GetContextPartitionAggregationService(context.AgentInstanceId);
ICollection<object> groupKeys = aggregationService.GetGroupKeys(context);
if (groupKeys.IsEmpty())
{
return null;
}
var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream);
var evaluateParams = new EvaluateParams(events, newData, context);
var result = new ArrayDeque<EventBean>(groupKeys.Count);
foreach (object groupKey in groupKeys)
{
aggregationService.SetCurrentAccess(groupKey, context.AgentInstanceId, null);
var pass = _havingClause.Evaluate(evaluateParams);
if (true.Equals(pass))
{
IDictionary<string, object> row = parent.EvaluateRow(events, true, context);
EventBean @event = parent.SubselectMultirowType.EventAdapterService.AdapterForTypedMap(
row, parent.SubselectMultirowType.EventType);
result.Add(@event);
}
}
return result;
}
public override void Update(
EventBean[] newData,
EventBean[] oldData)
{
agentInstanceContext.AuditProvider.View(newData, oldData, agentInstanceContext, factory);
agentInstanceContext.InstrumentationProvider.QViewProcessIRStream(factory, newData, oldData);
// add data points to the window
if (newData != null) {
foreach (var newEvent in newData) {
var pair = new ExpressionWindowTimestampEventPair(agentInstanceContext.TimeProvider.Time, newEvent);
window.Add(pair);
InternalHandleAdd(pair);
}
aggregationService?.ApplyEnter(newData, null, agentInstanceContext);
}
if (oldData != null) {
window.RemoveWhere(
pair => oldData.Any(anOldData => pair.TheEvent == anOldData),
InternalHandleRemoved);
aggregationService?.ApplyLeave(oldData, null, agentInstanceContext);
}
// expire events
Expire(newData, oldData);
agentInstanceContext.InstrumentationProvider.AViewProcessIRStream();
}
private void AddToWindow(
ArrayDeque <TimeWindowPair> testWindow,
long key,
object value)
{
testWindow.Add(new TimeWindowPair(key, value));
}
public ArrayDeque<Token> Tokenize(string str)
{
var tokens = new ArrayDeque<Token>(4);
while (!str.Equals("")) {
var match = false;
foreach (var info in tokenInfos) {
var m = info.regex.Match(str);
if (m != Match.Empty) {
match = true;
var tok = m.Value.Trim();
tokens.Add(new Token(info.token, tok));
str = info.regex.Replace(str, "", 1).Trim();
break;
}
}
if (!match) {
throw new PropertyParseNodepException("Unexpected token '" + str + "'");
}
}
return tokens;
}
public ICollection <EventBean> SnapshotNoLock(FilterSpecCompiled filter, Attribute[] annotations)
{
if (_tailView.RevisionProcessor != null)
{
return(_tailView.RevisionProcessor.GetSnapshot(_agentInstanceContext.EpStatementAgentInstanceHandle, Parent));
}
var indexedResult = _rootViewInstance.Snapshot(filter, annotations);
if (indexedResult != null)
{
return(indexedResult);
}
var en = Parent.GetEnumerator();
if (!en.MoveNext())
{
return(Collections.GetEmptyList <EventBean>());
}
var list = new ArrayDeque <EventBean>(1024);
do
{
list.Add(en.Current);
} while (en.MoveNext());
return(list);
}
public static AnnotationPart[] AnnotationsFromSpec(PatternStreamSpecRaw pattern)
{
Deque <AnnotationPart> parts = null;
if (pattern.IsDiscardPartialsOnMatch)
{
parts = new ArrayDeque <AnnotationPart>();
parts.Add(new AnnotationPart(DISCARDPARTIALSONMATCH));
}
if (pattern.IsSuppressSameEventMatches)
{
if (parts == null)
{
parts = new ArrayDeque <AnnotationPart>();
}
parts.Add(new AnnotationPart(SUPPRESSOVERLAPPINGMATCHES));
}
if (parts == null)
{
return(null);
}
return(parts.ToArray());
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return enumcoll;
}
var result = new ArrayDeque<object>();
var evalEvent = new ObjectArrayEventBean(new object[1], _forge.evalEventType);
eventsLambda[_forge.streamNumLambda] = evalEvent;
var evalProps = evalEvent.Properties;
var indexEvent = new ObjectArrayEventBean(new object[1], _forge.indexEventType);
eventsLambda[_forge.streamNumLambda + 1] = indexEvent;
var indexProps = indexEvent.Properties;
var count = -1;
foreach (var next in enumcoll) {
count++;
evalProps[0] = next;
indexProps[0] = count;
var pass = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (pass == null || false.Equals(pass)) {
continue;
}
result.Add(next);
}
return result;
}
public override void Update(
EventBean[] newData,
EventBean[] oldData)
{
agentInstanceContext.AuditProvider.View(newData, oldData, agentInstanceContext, lengthBatchViewFactory);
agentInstanceContext.InstrumentationProvider.QViewProcessIRStream(lengthBatchViewFactory, newData, oldData);
// we don't care about removed data from a prior view
if (newData == null || newData.Length == 0) {
return;
}
// add data points to the current batch
foreach (var newEvent in newData) {
currentBatch.Add(newEvent);
}
// check if we reached the minimum size
if (currentBatch.Count < Size) {
// done if no overflow
return;
}
SendBatch();
agentInstanceContext.InstrumentationProvider.AViewProcessIRStream();
}
/// <summary>
/// Add filter callback to an event evaluator, which could be either an index node or a set node.
/// </summary>
/// <param name="remainingParameters">The remaining parameters.</param>
/// <param name="filterCallback">The filter callback.</param>
/// <param name="eventEvaluator">to add the filterCallback to.</param>
/// <param name="treePathInfo">is for holding the information on where the add occured</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns>
/// bool indicating if the eventEvaluator was successfully added
/// </returns>
private static bool AddToEvaluator(
ArrayDeque <FilterValueSetParam> remainingParameters,
FilterHandle filterCallback,
EventEvaluator eventEvaluator,
ArrayDeque <EventTypeIndexBuilderIndexLookupablePair> treePathInfo,
FilterServiceGranularLockFactory lockFactory)
{
if (eventEvaluator is FilterHandleSetNode)
{
var node = (FilterHandleSetNode)eventEvaluator;
#if DEBUG && DIAGNOSTICS
System.Diagnostics.Debug.WriteLine("{0}: AddToEvaluator: {1}", Thread.CurrentThread.ManagedThreadId, node);
#endif
AddToNode(remainingParameters, filterCallback, node, treePathInfo, lockFactory);
return(true);
}
// Check if the next index matches any of the remaining filterCallback parameters
var nextIndex = (FilterParamIndexBase)eventEvaluator;
var parameter = IndexHelper.FindParameter(remainingParameters, nextIndex);
if (parameter != null)
{
remainingParameters.Remove(parameter);
treePathInfo.Add(new EventTypeIndexBuilderIndexLookupablePair(nextIndex, parameter.FilterForValue));
#if DEBUG && DIAGNOSTICS
System.Diagnostics.Debug.WriteLine("{0}: AddToEvaluator -> AddToIndex: {1}", Thread.CurrentThread.ManagedThreadId, nextIndex);
#endif
AddToIndex(remainingParameters, filterCallback, nextIndex, parameter.FilterForValue, treePathInfo, lockFactory);
return(true);
}
// This eventEvaluator does not work with any of the remaining filter parameters
return(false);
}
/// <summary>
/// Add filter callback to an event evaluator, which could be either an index node or a set node.
/// </summary>
/// <param name="remainingParameters">The remaining parameters.</param>
/// <param name="filterCallback">The filter callback.</param>
/// <param name="eventEvaluator">to add the filterCallback to.</param>
/// <param name="treePathInfo">is for holding the information on where the add occured</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns>
/// bool indicating if the eventEvaluator was successfully added
/// </returns>
private static bool AddToEvaluator(
ArrayDeque <FilterValueSetParam> remainingParameters,
FilterHandle filterCallback,
EventEvaluator eventEvaluator,
ArrayDeque <EventTypeIndexBuilderIndexLookupablePair> treePathInfo,
FilterServiceGranularLockFactory lockFactory)
{
if (eventEvaluator is FilterHandleSetNode)
{
var node = (FilterHandleSetNode)eventEvaluator;
AddToNode(remainingParameters, filterCallback, node, treePathInfo, lockFactory);
return(true);
}
// Check if the next index matches any of the remaining filterCallback parameters
var nextIndex = (FilterParamIndexBase)eventEvaluator;
var parameter = IndexHelper.FindParameter(remainingParameters, nextIndex);
if (parameter != null)
{
remainingParameters.Remove(parameter);
treePathInfo.Add(new EventTypeIndexBuilderIndexLookupablePair(nextIndex, parameter.FilterForValue));
AddToIndex(remainingParameters, filterCallback, nextIndex, parameter.FilterForValue, treePathInfo, lockFactory);
return(true);
}
// This eventEvaluator does not work with any of the remaining filter parameters
return(false);
}
private void Sweep(long currentTime)
{
var removed = new ArrayDeque <Object>();
foreach (var entry in _subViewsPerKey)
{
var age = currentTime - entry.Value.LastUpdateTime;
if (age > _reclaimMaxAge)
{
removed.Add(entry.Key);
}
}
foreach (var key in removed)
{
var entry = _subViewsPerKey.Delete(key);
var subviewHolder = entry.SubviewHolder;
if (subviewHolder is IList <View> )
{
var subviews = (IList <View>)subviewHolder;
foreach (var view in subviews)
{
RemoveSubview(view);
}
}
else if (subviewHolder is View)
{
RemoveSubview((View)subviewHolder);
}
}
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="sort">sorted</param>
/// <param name="hasColl">collection flag</param>
/// <param name="descending">true for descending</param>
/// <returns>collection</returns>
public static ICollection<object> EnumOrderBySortEval(
OrderedDictionary<object, object> sort,
bool hasColl,
bool descending)
{
IDictionary<object, object> sorted;
if (descending) {
sorted = sort.Invert();
}
else {
sorted = sort;
}
if (!hasColl) {
return sorted.Values;
}
Deque<object> coll = new ArrayDeque<object>();
foreach (var entry in sorted) {
if (entry.Value.GetType().IsGenericCollection()) {
coll.AddAll(entry.Value.Unwrap<object>());
}
else {
coll.Add(entry.Value);
}
}
return coll;
}
public ICollection<EventBean> SnapshotNoLock(
QueryGraph queryGraph,
Attribute[] annotations)
{
var indexedResult = _rootViewInstance.Snapshot(queryGraph, annotations);
if (indexedResult != null) {
return indexedResult;
}
return parent.ToList();
#if false
var enumerator = parent.GetEnumerator();
if (!enumerator.MoveNext()) {
return Collections.GetEmptyList<EventBean>();
}
var list = new ArrayDeque<EventBean>();
do {
list.Add(enumerator.Current);
} while (enumerator.MoveNext());
return list;
#endif
}
public static EventBean[] GetNewDataNonRemoved(
EventBean[] newData,
ISet<EventBean> removedEvents)
{
var filter = false;
for (var i = 0; i < newData.Length; i++) {
if (removedEvents.Contains(newData[i])) {
filter = true;
}
}
if (!filter) {
return newData;
}
if (newData.Length == 1) {
return null;
}
var events = new ArrayDeque<EventBean>(newData.Length - 1);
for (var i = 0; i < newData.Length; i++) {
if (!removedEvents.Contains(newData[i])) {
events.Add(newData[i]);
}
}
if (events.IsEmpty()) {
return null;
}
return events.ToArray();
}
public void Remove()
{
if (ExpectedModCount != outerInstance.ModCount)
{
throw new ConcurrentModificationException();
}
if (LastRet != -1)
{
E moved = OuterInstance.RemoveAt(LastRet);
LastRet = -1;
if (moved == null)
{
Cursor--;
}
else
{
if (ForgetMeNot == null)
{
ForgetMeNot = new ArrayDeque <>();
}
ForgetMeNot.Add(moved);
}
}
else if (LastRetElt != null)
{
OuterInstance.RemoveEq(LastRetElt);
LastRetElt = null;
}
else
{
throw new IllegalStateException();
}
ExpectedModCount = outerInstance.ModCount;
}
public object Evaluate(
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext exprEvaluatorContext)
{
var array = (Array) rootEvaluator.Evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
if (array == null) {
return null;
}
var len = array.Length;
if (len == 0) {
return Collections.GetEmptyList<object>();
}
if (len == 1) {
return Collections.SingletonList(array.GetValue(0));
}
Deque<object> dq = new ArrayDeque<object>(len);
for (var i = 0; i < len; i++) {
dq.Add(array.GetValue(i));
}
return dq;
}
public static EventBean[] GetNewDataNonRemoved(
EventBean[] newData,
ISet<EventBean> removedEvents,
EventBean[][] newEventsPerView)
{
if (newData == null || newData.Length == 0) {
return null;
}
if (newData.Length == 1) {
if (removedEvents.Contains(newData[0])) {
return null;
}
var pass = FindEvent(newData[0], newEventsPerView);
return pass ? newData : null;
}
var events = new ArrayDeque<EventBean>(newData.Length - 1);
for (var i = 0; i < newData.Length; i++) {
if (!removedEvents.Contains(newData[i])) {
var pass = FindEvent(newData[i], newEventsPerView);
if (pass) {
events.Add(newData[i]);
}
}
}
if (events.IsEmpty()) {
return null;
}
return events.ToArray();
}
public override ICollection <EventBean> EvaluateGetCollEvents(
EventBean[] eventsPerStream,
bool newData,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext context,
ExprSubselectRowNode parent)
{
ICollection <object> groupKeys = parent.SubselectAggregationService.GetGroupKeys(context);
if (groupKeys.IsEmpty())
{
return(null);
}
ICollection <EventBean> events = new ArrayDeque <EventBean>(groupKeys.Count);
foreach (object groupKey in groupKeys)
{
parent.SubselectAggregationService.SetCurrentAccess(groupKey, context.AgentInstanceId, null);
IDictionary <string, object> row = parent.EvaluateRow(null, true, context);
EventBean @event = parent.subselectMultirowType.EventAdapterService.AdapterForTypedMap(
row, parent.subselectMultirowType.EventType);
events.Add(@event);
}
return(events);
}
