public void LookupRange(
ISet<EventBean> result,
IOrderedDictionary<object, CompositeIndexEntry> propertyIndex,
object keyStart,
bool includeStart,
object keyEnd,
bool includeEnd,
bool allowRangeReversal,
CompositeIndexQueryResultPostProcessor postProcessor)
{
if (keyStart == null || keyEnd == null) {
return;
}
keyStart = Coerce(keyStart);
keyEnd = Coerce(keyEnd);
IDictionary<object, CompositeIndexEntry> submap;
if (propertyIndex.KeyComparer.Compare(keyStart, keyEnd) <= 0) {
submap = propertyIndex.Between(keyStart, includeStart, keyEnd, includeEnd);
}
else if (allowRangeReversal) {
submap = propertyIndex.Between(keyEnd, includeStart, keyStart, includeEnd);
}
else {
return;
}
Normalize(result, submap, postProcessor);
}
/// <summary>
/// Returns the set of events that have the same property value as the given event.
/// </summary>
/// <param name="keyStart">to compare against</param>
/// <param name="includeStart">indicates if we should include the start point</param>
/// <param name="keyEnd">to compare against</param>
/// <param name="includeEnd">indicates if we should include the end point</param>
/// <param name="allowRangeReversal">
/// indicate whether "a between 60 and 50" should return no results (equivalent to a&
/// gt;= X and a &lt;=Y) or should return results (equivalent to 'between' and 'in'
/// </param>
/// <returns>set of events with property value, or null if none found (never returns zero-sized set)</returns>
public override ISet<EventBean> LookupRange(
object keyStart,
bool includeStart,
object keyEnd,
bool includeEnd,
bool allowRangeReversal)
{
if (keyStart == null || keyEnd == null) {
return Collections.GetEmptySet<EventBean>();
}
keyStart = Coerce(keyStart);
keyEnd = Coerce(keyEnd);
IDictionary<object, ISet<EventBean>> submap;
if (propertyIndex.KeyComparer.Compare(keyStart, keyEnd) <= 0) {
submap = propertyIndex.Between(keyStart, includeStart, keyEnd, includeEnd);
} else if (allowRangeReversal) {
submap = propertyIndex.Between(keyEnd, includeStart, keyStart, includeEnd);
}
else {
return Collections.GetEmptySet<EventBean>();
}
return Normalize(submap);
}
private static void AssertEventsBetween <T>(
IOrderedDictionary <int, T> treemap,
MySubmapEvent sme,
SupportBean[] events,
SupportBean lastOf)
where T : ICollection <SupportBean>
{
var submap = treemap.Between(sme.FromKey, sme.IsFromInclusive, sme.ToKey, sme.IsToInclusive);
var all = new List <SupportBean>();
foreach (var entry in submap)
{
all.AddAll(entry.Value);
}
EPAssertionUtil.AssertEqualsExactOrder(all.ToArray(), events);
if (all.IsEmpty())
{
Assert.IsNull(lastOf);
}
else
{
Assert.AreEqual(all[all.Count - 1], lastOf);
}
}
public ICollection<EventBean> Lookup(
EventBean theEvent,
IDictionary<object, CompositeIndexEntry> parent,
ICollection<EventBean> result,
CompositeIndexQuery next,
ExprEvaluatorContext context,
ICollection<object> optionalKeyCollector,
CompositeIndexQueryResultPostProcessor postProcessor)
{
object comparableStart = base.EvaluateLookupStart(theEvent, context);
optionalKeyCollector?.Add(comparableStart);
if (comparableStart == null) {
return null;
}
object comparableEnd = base.EvaluateLookupEnd(theEvent, context);
optionalKeyCollector?.Add(comparableEnd);
if (comparableEnd == null) {
return null;
}
IOrderedDictionary<object, CompositeIndexEntry> index =
(IOrderedDictionary<object, CompositeIndexEntry>) parent;
IDictionary<object, CompositeIndexEntry> submap;
if (index.KeyComparer.Compare(comparableStart, comparableEnd) <= 0) {
submap = index.Between(comparableStart, includeStart, comparableEnd, includeEnd);
}
else if (_allowReverseRange) {
submap = index.Between(comparableEnd, includeStart, comparableStart, includeEnd);
}
else {
return null;
}
return CompositeIndexQueryRange.Handle(theEvent, submap, null, result, next, postProcessor);
}
/// <summary>
/// Returns a readonly ordered dictionary that includes everything between the
/// two provided values. Whether each value is included in the range depends
/// on whether the isInclusive flag is set.
/// </summary>
/// <returns></returns>
public IOrderedDictionary <TK1, TV1> Between(
TK1 startValue,
bool isStartInclusive,
TK1 endValue,
bool isEndInclusive)
{
return(new TransformOrderedDictionary <TK1, TV1, TK2, TV2>(
_subDictionaryOrdered.Between(
KeyIn(startValue), isStartInclusive,
KeyIn(endValue), isEndInclusive),
KeyOut,
KeyIn,
ValueOut,
ValueIn));
}
private static void AssertSubmap <T>(
IOrderedDictionary <int, T> treemap,
MySubmapEvent sme,
IDictionary <object, SupportBean[]> actual)
where T : ICollection <SupportBean>
{
var expected = treemap.Between(sme.FromKey, sme.IsFromInclusive, sme.ToKey, sme.IsToInclusive);
Assert.AreEqual(expected.Count, actual.Count);
foreach (var key in expected.Keys)
{
var expectedEvents = expected.Get(key).ToArray();
var actualEvents = actual.Get(key);
EPAssertionUtil.AssertEqualsExactOrder(expectedEvents, actualEvents);
}
}
private static void AssertOrderedDictionary(
IOrderedDictionary <int, IList <SupportBean> > treemap,
IOrderedDictionary <object, ICollection <EventBean> > actual)
{
Assert.AreEqual(treemap.Count, actual.Count);
foreach (var key in treemap.Keys)
{
var expectedEvents = treemap.Get(key).ToArray();
EPAssertionUtil.AssertEqualsExactOrder(expectedEvents, ToArrayOfUnderlying(actual.Get(key)));
}
CompareEntry(treemap.First(), actual.FirstEntry);
CompareEntry(treemap.Last(), actual.LastEntry);
CompareEntry(treemap.LessThanOrEqualTo(5), actual.LessThanOrEqualTo(5));
CompareEntry(treemap.GreaterThanOrEqualTo(5), actual.GreaterThanOrEqualTo(5));
CompareEntry(treemap.LessThan(5), actual.LessThan(5));
CompareEntry(treemap.GreaterThan(5), actual.GreaterThan(5));
Assert.AreEqual(treemap.Keys.First(), actual.FirstEntry.Key);
Assert.AreEqual(treemap.Keys.Last(), actual.LastEntry.Key);
Assert.AreEqual(treemap.LessThanOrEqualTo(5)?.Key, actual.LessThanOrEqualTo(5)?.Key);
Assert.AreEqual(treemap.GreaterThanOrEqualTo(5)?.Key, actual.GreaterThanOrEqualTo(5)?.Key);
Assert.AreEqual(treemap.LessThan(5)?.Key, actual.LessThan(5)?.Key);
Assert.AreEqual(treemap.GreaterThan(5)?.Key, actual.GreaterThan(5)?.Key);
Assert.AreEqual(treemap.ContainsKey(5), actual.ContainsKey(5));
Assert.AreEqual(treemap.IsEmpty(), actual.IsEmpty());
EPAssertionUtil.AssertEqualsExactOrder(new object[] { 1, 4, 6, 8, 9 }, actual.Keys.ToArray());
Assert.AreEqual(1, actual.Between(9, true, 9, true).Count);
Assert.AreEqual(1, actual.Tail(9).Count);
Assert.AreEqual(1, actual.Tail(9, true).Count);
Assert.AreEqual(1, actual.Head(2).Count);
Assert.AreEqual(1, actual.Head(2, false).Count);
Assert.AreEqual(5, actual.Count);
Assert.AreEqual(5, actual.Keys.Count);
Assert.AreEqual(5, actual.Values.Count);
// values
var values = actual.Values;
Assert.That(values.Count, Is.EqualTo(5));
Assert.That(values.IsEmpty(), Is.False);
var valuesEnum = values.GetEnumerator();
Assert.That(valuesEnum, Is.Not.Null);
Assert.That(valuesEnum.MoveNext, Is.True);
CollectionAssert.AreEqual(
treemap.Get(1).ToArray(),
ToArrayOfUnderlying(valuesEnum.Current));
Assert.That(valuesEnum.MoveNext, Is.True);
Assert.That(values.ToArray(), Has.Length.EqualTo(5));
CollectionAssert.AreEqual(
treemap.Get(1).ToArray(),
ToArrayOfUnderlying((ICollection <EventBean>)values.ToArray()[0]));
// ordered key set
var oks = actual.OrderedKeys;
//Assert.That(oks.Comparator());
Assert.That(oks.FirstEntry, Is.EqualTo(1));
Assert.That(oks.LastEntry, Is.EqualTo(9));
Assert.That(oks.Count, Is.EqualTo(5));
Assert.That(oks.IsEmpty(), Is.False);
Assert.That(oks.Contains(6), Is.True);
Assert.That(oks.ToArray(), Is.Not.Null);
Assert.That(oks.LessThan(5), Is.EqualTo(4));
Assert.That(oks.GreaterThan(5), Is.EqualTo(6));
Assert.That(oks.LessThanOrEqualTo(5), Is.EqualTo(4));
Assert.That(oks.GreaterThanOrEqualTo(5), Is.EqualTo(6));
Assert.That(oks.Between(1, true, 100, true), Is.Not.Null);
Assert.That(oks.Head(100, true), Is.Not.Null);
Assert.That(oks.Tail(1, true), Is.Not.Null);
// ordered key set - enumerator
var oksit = oks.GetEnumerator();
Assert.That(oksit, Is.Not.Null);
Assert.That(oksit.MoveNext(), Is.True);
Assert.That(oksit.Current, Is.EqualTo(1));
Assert.That(oksit.MoveNext(), Is.True);
// entry set
ICollection <KeyValuePair <object, ICollection <EventBean> > > set = actual;
Assert.IsFalse(set.IsEmpty());
var setit = set.GetEnumerator();
var entry = setit.Advance();
Assert.AreEqual(1, entry.Key);
Assert.IsTrue(setit.MoveNext());
EPAssertionUtil.AssertEqualsExactOrder(treemap.Get(1).ToArray(), ToArrayOfUnderlying(entry.Value));
var array = set.ToArray();
Assert.AreEqual(5, array.Length);
Assert.AreEqual(1, array[0].Key);
EPAssertionUtil.AssertEqualsExactOrder(treemap.Get(1).ToArray(), ToArrayOfUnderlying(array[0].Value));
Assert.IsNotNull(set.ToArray());
// sorted map
var events = actual.Head(100);
Assert.AreEqual(5, events.Count);
}
