public void SetWindow(
ArrayDeque <TimeWindowPair> window,
int size)
{
_window = window;
_size = size;
}
/// <summary>
/// Flatten the vector of arrays to an array. Return null if an empty vector was passed, else
/// return an array containing all the events.
/// </summary>
/// <param name="eventVector">vector</param>
/// <returns>array with all events</returns>
public static EventBean[] Flatten(ArrayDeque<EventBean[]> eventVector)
{
if (eventVector.IsEmpty()) {
return null;
}
if (eventVector.Count == 1) {
return eventVector.First;
}
var totalElements = 0;
foreach (var arr in eventVector) {
if (arr != null) {
totalElements += arr.Length;
}
}
if (totalElements == 0) {
return null;
}
var result = new EventBean[totalElements];
var destPos = 0;
foreach (var arr in eventVector) {
if (arr != null) {
Array.Copy(arr, 0, result, destPos, arr.Length);
destPos += arr.Length;
}
}
return result;
}
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 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 TestEmpty()
{
var testWindow = new ArrayDeque <TimeWindowPair>();
IEnumerator <EventBean> enumerator = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(null, enumerator);
}
// Filter and no-select
public ICollection <EventBean> EvaluateGetCollEvents(
EventBean[] eventsPerStream,
bool newData,
ICollection <EventBean> matchingEvents,
ExprEvaluatorContext context,
ExprSubselectRowNode parent)
{
var events = EventBeanUtility.AllocatePerStreamShift(eventsPerStream);
var evaluateParams = new EvaluateParams(events, true, context);
ArrayDeque <EventBean> filtered = null;
foreach (var subselectEvent in matchingEvents)
{
events[0] = subselectEvent;
var pass = parent.FilterExpr.Evaluate(evaluateParams);
if ((pass != null) && true.Equals(pass))
{
if (filtered == null)
{
filtered = new ArrayDeque <EventBean>();
}
filtered.Add(subselectEvent);
}
}
return(filtered);
}
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;
}
/// <summary>
/// The Graham Scan algorithm determines the points belonging to the convex hull in O(n lg n).
/// </summary>
/// <param name="points">set of points</param>
/// <returns>points in the convex hull</returns>
/// <seealso href="http://en.wikipedia.org/wiki/Graham_scan">Graham scan, Wikipedia</seealso>
public static List <Point> GrahamScan(List <Point> points)
{
if (points.Count <= 3)
{
return(new List <Point>(points));
}
var ps = new List <Point>(points);
ps.Sort(new CompareYThenX());
ps.Sort(new PolarComparator(ps[0]));
Deque <Point> hull = new ArrayDeque <Point>();
hull.Push(ps[0]);
hull.Push(ps[1]);
hull.Push(ps[2]);
for (int i = 3; i < points.Count; i++)
{
var top = hull.Pop();
while (hull.Any() && !IsLeftTurn(hull.Peek(), top, ps[i]))
{
top = hull.Pop();
}
hull.Push(top);
hull.Push(ps[i]);
}
return(new List <Point>(hull));
}
protected long EvaluateInternal(
EventBean theEvent,
ICollection<FilterHandle> matches,
int statementId,
ExprEvaluatorContext ctx)
{
var version = filtersVersion;
numEventsEvaluated.IncrementAndGet();
var allMatches = new ArrayDeque<FilterHandle>();
// Finds all matching filters
RetryableMatchEvent(theEvent, allMatches, ctx);
// Add statement matches to collection passed
foreach (var match in allMatches) {
if (match.StatementId == statementId) {
matches.Add(match);
}
}
if (AuditPath.isAuditEnabled && !filterServiceListeners.IsEmpty()) {
foreach (var listener in filterServiceListeners) {
listener.Filtering(theEvent, matches, statementId);
}
}
return version;
}
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 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 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 void Lookup(
EventBean[] lookupEvents,
ICollection<MultiKeyArrayOfKeys<EventBean>> joinSet,
ExprEvaluatorContext exprEvaluatorContext)
{
if (lookupEvents == null || lookupEvents.Length == 0) {
return;
}
var results = new ArrayDeque<EventBean[]>();
foreach (var theEvent in lookupEvents) {
// Set up prototype row
var prototype = new EventBean[NumStreams];
prototype[ForStream] = theEvent;
// Perform execution
ExecNode.Process(theEvent, prototype, results, exprEvaluatorContext);
// Convert results into unique set
foreach (var row in results) {
joinSet.Add(new MultiKeyArrayOfKeys<EventBean>(row));
}
results.Clear();
}
}
public static bool EvaluateFilterForStatement(EPServicesContext servicesContext, EventBean theEvent, AgentInstanceContext agentInstanceContext, FilterHandle filterHandle)
{
// context was created - reevaluate for the given event
var callbacks = new ArrayDeque <FilterHandle>();
servicesContext.FilterService.Evaluate(theEvent, callbacks, agentInstanceContext.StatementContext.StatementId);
try
{
servicesContext.VariableService.SetLocalVersion();
// sub-selects always go first
if (callbacks.Any(handle => handle == filterHandle))
{
return(true);
}
agentInstanceContext.EpStatementAgentInstanceHandle.InternalDispatch();
}
catch (Exception ex)
{
servicesContext.ExceptionHandlingService.HandleException(
ex, agentInstanceContext.EpStatementAgentInstanceHandle, ExceptionHandlerExceptionType.PROCESS,
theEvent);
}
return(false);
}
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 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);
}
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;
}
protected long EvaluateInternal(EventBean theEvent, ICollection <FilterHandle> matches, String statementId)
{
long version = _filtersVersion;
Interlocked.Increment(ref _numEventsEvaluated);
//_numEventsEvaluated.IncrementAndGet();
ArrayDeque <FilterHandle> allMatches = new ArrayDeque <FilterHandle>();
// Finds all matching filters
RetryableMatchEvent(theEvent, allMatches);
// Add statement matches to collection passed
foreach (FilterHandle match in allMatches)
{
if (match.StatementId.Equals(statementId))
{
matches.Add(match);
}
}
if ((AuditPath.IsAuditEnabled) && (_filterServiceListeners.IsNotEmpty()))
{
foreach (FilterServiceListener listener in _filterServiceListeners)
{
listener.Filtering(theEvent, matches, statementId);
}
}
return(version);
}
private ICollection <EventBean> GetFiltered(ICollection <EventBean> snapshot, IList <ExprNode> filterExpressions)
{
var deque = new ArrayDeque <EventBean>(Math.Min(snapshot.Count, 16));
ExprNodeUtility.ApplyFilterExpressionsIterable(snapshot, filterExpressions, _agentInstanceContext, deque);
return(deque);
}
/// <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 virtual bool doesChildExistAtScope(Node child)
{
Deque <string> tempScope = new ArrayDeque <string>();
tempScope.push(currentScope.pop());
bool doesExist = false;
while (!currentScope.Empty)
{
if (child is VariableNode)
{
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
doesExist = scopeHash[tempScope.peek()].children.stream().filter(f => f is VariableNode).filter(t => ((VariableNode)t).variableName.Equals(((VariableNode)child).variableName)).count() == 1;
}
else if (child is UserDefinedTypeNode)
{
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
doesExist = scopeHash[tempScope.peek()].children.stream().filter(f => f is UserDefinedTypeNode).filter(t => ((VariableNode)t).variableName.Equals(((UserDefinedTypeNode)child).TypeName)).count() == 1;
}
if (doesExist)
{
break;
}
tempScope.push(currentScope.pop());
}
while (!tempScope.Empty)
{
currentScope.push(tempScope.pop());
}
return(doesExist);
}
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);
}
private void AddToWindow(
ArrayDeque <TimeWindowPair> testWindow,
long key,
object value)
{
testWindow.Add(new TimeWindowPair(key, value));
}
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);
}
}
}
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 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 ICollection<EventBean> GetDistinctByProp(
ArrayDeque<EventBean> events,
EventPropertyValueGetter getter)
{
if (events == null || events.IsEmpty()) {
return new EventBean[0];
}
if (events.Count < 2) {
return events;
}
var map = new LinkedHashMap<object, EventBean>();
if (events.First is NaturalEventBean) {
foreach (var theEvent in events) {
var inner = ((NaturalEventBean) theEvent).OptionalSynthetic;
var key = getter.Get(inner);
map[key] = inner;
}
}
else {
foreach (var theEvent in events) {
var key = getter.Get(theEvent);
map[key] = theEvent;
}
}
return map.Values.ToArray();
}
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 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 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;
}
