public void TestMixedEntryElement()
{
var list1 = new List <EventBean>();
list1.Add(events.Get("a"));
var keyA = new HashableMultiKey(new object[] { "keyA" });
testMap.Put(keyA, list1);
var list2 = new List <EventBean>();
list2.Add(events.Get("c"));
list2.Add(events.Get("d"));
var keyB = new HashableMultiKey(new object[] { "keyB" });
testMap.Put(keyB, list2);
var list3 = new List <EventBean>();
list3.Add(events.Get("e"));
list3.Add(events.Get("f"));
list3.Add(events.Get("g"));
var keyC = new HashableMultiKey(new object[] { "keyC" });
testMap.Put(keyC, list3);
var enumerator = testMap.GetMultiLevelEnumerator();
EPAssertionUtil.AssertEqualsExactOrder(
new[] {
events.Get("a"), events.Get("c"), events.Get("d"),
events.Get("e"), events.Get("f"), events.Get("g")
}, enumerator);
}
private EventBean InplaceReplaceSortedEvents(
object sortKey,
object uniqueKeyToReplace,
EventBean newData)
{
var existing = _sortedEvents.Get(sortKey);
EventBean replaced = null;
if (existing != null) {
if (existing is IList<EventBean> existingList) {
for (int ii = 0; ii < existingList.Count; ii++) {
var eventForRank = existingList[ii];
if (GetUniqueKey(eventForRank).Equals(uniqueKeyToReplace)) {
existingList.RemoveAt(ii--);
replaced = eventForRank;
break;
}
}
existingList.Add(newData); // add to back as this is now the newest event
}
else {
replaced = (EventBean) existing;
_sortedEvents.Put(sortKey, newData);
}
}
return replaced;
}
private static ExprNode HandlePreviousFunctions(
ExprNode defineItemExpression,
IOrderedDictionary<int, IList<ExprPreviousMatchRecognizeNode>> previousNodes)
{
var previousVisitor = new ExprNodePreviousVisitorWParent();
defineItemExpression.Accept(previousVisitor);
if (previousVisitor.Previous == null) {
return defineItemExpression;
}
foreach (var previousNodePair in previousVisitor.Previous) {
var previousNode = previousNodePair.Second;
var matchRecogPrevNode = new ExprPreviousMatchRecognizeNode();
if (previousNodePair.Second.ChildNodes.Length == 1) {
matchRecogPrevNode.AddChildNode(previousNode.ChildNodes[0]);
matchRecogPrevNode.AddChildNode(new ExprConstantNodeImpl(1));
}
else if (previousNodePair.Second.ChildNodes.Length == 2) {
var first = previousNode.ChildNodes[0];
var second = previousNode.ChildNodes[1];
if (first is ExprConstantNode && !(second is ExprConstantNode)) {
matchRecogPrevNode.AddChildNode(second);
matchRecogPrevNode.AddChildNode(first);
}
else if (!(first is ExprConstantNode) && second is ExprConstantNode) {
matchRecogPrevNode.AddChildNode(first);
matchRecogPrevNode.AddChildNode(second);
}
else {
throw new ExprValidationException("PREV operator requires a constant index");
}
}
if (previousNodePair.First == null) {
defineItemExpression = matchRecogPrevNode;
}
else {
ExprNodeUtilityModify.ReplaceChildNode(
previousNodePair.First,
previousNodePair.Second,
matchRecogPrevNode);
}
// store in a list per index such that we can consolidate this into a single buffer
var index = matchRecogPrevNode.ConstantIndexNumber;
var callbackList = previousNodes.Get(index);
if (callbackList == null) {
callbackList = new List<ExprPreviousMatchRecognizeNode>();
previousNodes.Put(index, callbackList);
}
callbackList.Add(matchRecogPrevNode);
}
return defineItemExpression;
}
private void AddTrigger(long slot, ScheduleHandle handle, long triggerTime)
{
var handleSet = _timeHandleMap.Get(triggerTime);
if (handleSet == null)
{
handleSet = new SortedDictionary<long, ScheduleHandle>();
_timeHandleMap.Put(triggerTime, handleSet);
}
handleSet.Put(slot, handle);
_handleSetMap.Put(handle, handleSet);
}
private static void MakeSendBean(
RegressionEnvironment env,
IOrderedDictionary <int, IList <SupportBean> > treemap,
string theString,
int intPrimitive)
{
var bean = new SupportBean(theString, intPrimitive);
env.SendEventBean(bean);
var existing = treemap.Get(intPrimitive);
if (existing == null)
{
existing = new List <SupportBean>();
treemap.Put(intPrimitive, existing);
}
existing.Add(bean);
treemap.Put(bean.IntPrimitive, existing);
}
public override void Put(
object filterConstant,
EventEvaluator matcher)
{
constantsMap.Put(filterConstant, matcher);
// Update bounds
double constant = filterConstant.AsDouble();
if (lowerBounds == null || constant < lowerBounds) {
lowerBounds = constant;
}
if (upperBounds == null || constant > upperBounds) {
upperBounds = constant;
}
}
public override void Put(
object expressionValue,
EventEvaluator matcher)
{
if (!(expressionValue is StringRange))
{
throw new ArgumentException("Supplied expressionValue must be of type DoubleRange");
}
var range = (StringRange)expressionValue;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = matcher;
return;
}
Ranges.Put(range, matcher);
}
public override void Add(
EventBean theEvent,
ExprEvaluatorContext exprEvaluatorContext)
{
var key = GetIndexedValue(theEvent);
key = Coerce(key);
if (key == null) {
nullKeyedValues.Add(theEvent);
return;
}
var events = propertyIndex.Get(key);
if (events == null) {
events = new LinkedHashSet<EventBean>();
propertyIndex.Put(key, events);
}
events.Add(theEvent);
}
public override void Put(
object expressionValue,
EventEvaluator matcher)
{
if (!(expressionValue is DoubleRange))
{
throw new ArgumentException("Supplied expressionValue must be of type DoubleRange");
}
var range = (DoubleRange)expressionValue;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = matcher;
return;
}
if (Math.Abs(range.Max.Value - range.Min.Value) > LargestRangeValueDouble)
{
LargestRangeValueDouble = Math.Abs(range.Max.Value - range.Min.Value);
}
Ranges.Put(range, matcher);
}
public override void Put(
object filterConstant,
EventEvaluator matcher)
{
constantsMap.Put(filterConstant, matcher);
}
