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