public void TestInvalid()
{
comparator = new MultiKeyComparator(new bool[] { false, false });
firstValues = new MultiKeyUntyped(new Object[] { 3d });
secondValues = new MultiKeyUntyped(new Object[] { 3d, 4L });
try
{
comparator.Compare(firstValues, secondValues);
Assert.Fail();
}
catch (ArgumentException e)
{
// Expected
}
firstValues = new MultiKeyUntyped(new Object[] { 3d });
secondValues = new MultiKeyUntyped(new Object[] { 3d });
try
{
comparator.Compare(firstValues, secondValues);
Assert.Fail();
}
catch (ArgumentException e)
{
// Expected
}
}
public void TestIndex()
{
FilterParamIndexIn index = new FilterParamIndexIn(MakeLookupable("LongBoxed"), ReaderWriterLockManager.CreateDefaultLock());
Assert.AreEqual(FilterOperator.IN_LIST_OF_VALUES, index.FilterOperator);
MultiKeyUntyped inList = new MultiKeyUntyped(new Object[] { 2L, 5L });
index.Put(inList, _testEvaluator);
inList = new MultiKeyUntyped(new Object[] { 10L, 5L });
index.Put(inList, _testEvaluator);
Verify(index, 1L, 0);
Verify(index, 2L, 1);
Verify(index, 5L, 2);
Verify(index, 10L, 1);
Verify(index, 999L, 0);
Verify(index, null, 0);
Assert.AreEqual(_testEvaluator, index.Get(inList));
Assert.IsTrue(index.ReadWriteLock != null);
Assert.IsTrue(index.Remove(inList));
Assert.IsFalse(index.Remove(inList));
Assert.AreEqual(null, index.Get(inList));
try
{
index["a"] = _testEvaluator;
Assert.IsTrue(false);
}
catch (Exception ex)
{
// Expected
}
}
private static void Add(QueryGraphRangeEnum opOne, QueryGraphRangeEnum opTwo, QueryGraphRangeEnum range)
{
MultiKeyUntyped keyOne = GetKey(opOne, opTwo);
OPS_TABLE.Put(keyOne, new QueryGraphRangeConsolidateDesc(range, false));
MultiKeyUntyped keyRev = GetKey(opTwo, opOne);
OPS_TABLE.Put(keyRev, new QueryGraphRangeConsolidateDesc(range, true));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="lookupable">is the event property name</param>
/// <param name="filterOperator">is expected to be the IN-list operator</param>
/// <param name="listofValues">is a list of constants and event property names</param>
/// <throws>ArgumentException for illegal args</throws>
public FilterSpecParamIn(FilterSpecLookupable lookupable, FilterOperator filterOperator, IList <FilterSpecParamInValue> listofValues)
: base(lookupable, filterOperator)
{
_listOfValues = listofValues;
bool isAllConstants = false;
foreach (FilterSpecParamInValue value in listofValues)
{
if (value is InSetOfValuesEventProp || value is InSetOfValuesContextProp)
{
isAllConstants = false;
break;
}
}
if (isAllConstants)
{
Object[] constants = new Object[_listOfValues.Count];
int count = 0;
foreach (FilterSpecParamInValue valuePlaceholder in _listOfValues)
{
constants[count++] = valuePlaceholder.GetFilterValue(null, null);
}
_inListConstantsOnly = new MultiKeyUntyped(constants);
}
if ((filterOperator != FilterOperator.IN_LIST_OF_VALUES) && ((filterOperator != FilterOperator.NOT_IN_LIST_OF_VALUES)))
{
throw new ArgumentException("Illegal filter operator " + filterOperator + " supplied to " +
"in-values filter parameter");
}
}
/// <summary>
/// Returns the computer to use for the relational operation based on the
/// coercion type.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="coercedType">is the object type</param>
/// <param name="typeOne">The type one.</param>
/// <param name="typeTwo">The type two.</param>
/// <returns>
/// computer for performing the relational op
/// </returns>
public static Computer GetComputer(this RelationalOpEnum value, Type coercedType, Type typeOne, Type typeTwo)
{
var t = Nullable.GetUnderlyingType(coercedType);
if (t != null)
{
coercedType = t;
}
var key = new MultiKeyUntyped(new Object[] { coercedType, value });
var computer = Computers.Get(key, null);
if (computer == null)
{
if (typeOne.IsComparable() && typeTwo.IsComparable())
{
key = new MultiKeyUntyped(new object[] { typeof(IComparable), value });
computer = Computers.Get(key, null);
if (computer != null)
{
return(computer);
}
}
throw new ArgumentException("Unsupported type for relational op compare, type " + coercedType);
}
return(computer);
}
public void TestTwoSeparateEntryElement()
{
var list1 = new List <EventBean>();
list1.Add(_events.Get("a"));
var keyB = new MultiKeyUntyped(
new Object[]
{
"keyB"
}
);
_testMap.Put(keyB, list1);
var list2 = new List <EventBean>();
list2.Add(_events.Get("b"));
var keyA = new MultiKeyUntyped(
new Object[]
{
"keyA"
}
);
_testMap.Put(keyA, list2); // Actually before list1
IEnumerator <EventBean> it = new SortWindowEnumerator(_testMap);
EPAssertionUtil.AssertEqualsExactOrder(
new EventBean[]
{
_events.Get("b"), _events.Get("a")
}
, it);
}
public Object[] GetSortKeyPerRow(EventBean[] generatingEvents, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
if (generatingEvents == null)
{
return(null);
}
var sortProperties = new Object[generatingEvents.Length];
var count = 0;
var evalEventsPerStream = new EventBean[1];
var evaluateParams = new EvaluateParams(evalEventsPerStream, isNewData, exprEvaluatorContext);
if (_factory.OrderBy.Length == 1)
{
var singleEval = _factory.OrderBy[0].Expr;
foreach (var theEvent in generatingEvents)
{
evalEventsPerStream[0] = theEvent;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(evalEventsPerStream, _factory.OrderBy);
}
sortProperties[count] = singleEval.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(sortProperties[count]);
}
count++;
}
}
else
{
foreach (var theEvent in generatingEvents)
{
var values = new Object[_factory.OrderBy.Length];
var countTwo = 0;
evalEventsPerStream[0] = theEvent;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(evalEventsPerStream, _factory.OrderBy);
}
foreach (var sortPair in _factory.OrderBy)
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
sortProperties[count] = new MultiKeyUntyped(values);
count++;
}
}
return(sortProperties);
}
private static void Add(QueryGraphRangeEnum opOne, QueryGraphRangeEnum opTwo, QueryGraphRangeEnum range)
{
MultiKeyUntyped keyOne = GetKey(opOne, opTwo);
opsTable[keyOne] = new QueryGraphRangeConsolidateDesc(range, false);
MultiKeyUntyped keyRev = GetKey(opTwo, opOne);
opsTable[keyRev] = new QueryGraphRangeConsolidateDesc(range, true);
}
private void GetGroupedResults(IDictionary <Object, UniformPair <EventBean[]> > groups, IEnumerable <EventBean> events, bool insertStream, EventBean[] eventsPerStream)
{
if (events == null)
{
return;
}
foreach (EventBean theEvent in events)
{
EventBean evalEvent = theEvent;
if (evalEvent is NaturalEventBean)
{
evalEvent = ((NaturalEventBean)evalEvent).OptionalSynthetic;
}
Object key;
eventsPerStream[0] = evalEvent;
if (_groupDeliveryExpressions.Length == 1)
{
key = _groupDeliveryExpressions[0].Evaluate(new EvaluateParams(eventsPerStream, true, _exprEvaluatorContext));
}
else
{
var keys = new Object[_groupDeliveryExpressions.Length];
for (int i = 0; i < _groupDeliveryExpressions.Length; i++)
{
keys[i] = _groupDeliveryExpressions[i].Evaluate(new EvaluateParams(eventsPerStream, true, _exprEvaluatorContext));
}
key = new MultiKeyUntyped(keys);
}
UniformPair <EventBean[]> groupEntry = groups.Get(key);
if (groupEntry == null)
{
groupEntry = insertStream
? new UniformPair <EventBean[]>(new[] { theEvent }, null)
: new UniformPair <EventBean[]>(null, new[] { theEvent });
groups.Put(key, groupEntry);
}
else
{
if (insertStream)
{
groupEntry.First = groupEntry.First == null
? new[] { theEvent }
: EventBeanUtility.AddToArray(groupEntry.First, theEvent);
}
else
{
groupEntry.Second = groupEntry.Second == null
? new[] { theEvent }
: EventBeanUtility.AddToArray(groupEntry.Second, theEvent);
}
}
}
}
public void Lookup(IDictionary <object, object> parent, ICollection <EventBean> result)
{
var mk = new MultiKeyUntyped(_keys);
var innerIndex = (IDictionary <object, object>)parent.Get(mk);
if (innerIndex == null)
{
return;
}
_next.Lookup(innerIndex, result);
}
public void Lookup(IDictionary <object, object> parent, ICollection <EventBean> result, CompositeIndexQueryResultPostProcessor postProcessor)
{
var mk = new MultiKeyUntyped(_keys);
var innerIndex = (IDictionary <object, object>)parent.Get(mk);
if (innerIndex == null)
{
return;
}
_next.Lookup(innerIndex, result, postProcessor);
}
public override ISet <EventBean> Lookup(object[] keys)
{
var key = new MultiKeyUntyped(keys);
var @event = _propertyIndex.Get(key);
if (@event != null)
{
return(Collections.SingletonSet(@event));
}
return(null);
}
public void TestCompareTwoProperties()
{
comparator = new MultiKeyComparator(new bool[] { false, false });
firstValues = new MultiKeyUntyped(new Object[] { 3d, 3L });
secondValues = new MultiKeyUntyped(new Object[] { 3d, 4L });
Assert.IsTrue(comparator.Compare(firstValues, secondValues) < 0);
comparator = new MultiKeyComparator(new bool[] { false, true });
Assert.IsTrue(comparator.Compare(firstValues, secondValues) > 0);
Assert.IsTrue(comparator.Compare(firstValues, firstValues) == 0);
}
public void TestCompareSingleProperty()
{
comparator = new MultiKeyComparator(new bool[] { false });
firstValues = new MultiKeyUntyped(new Object[] { 3d });
secondValues = new MultiKeyUntyped(new Object[] { 4d });
Assert.IsTrue(comparator.Compare(firstValues, secondValues) < 0);
comparator = new MultiKeyComparator(new bool[] { true });
Assert.IsTrue(comparator.Compare(firstValues, secondValues) > 0);
Assert.IsTrue(comparator.Compare(firstValues, firstValues) == 0);
}
public void TestMultiKey()
{
// try 2 properties
EventPropertyGetter[] getters = MakeGetters();
EventBean theEvent = SupportEventBeanFactory.CreateObject(new SupportBean("a", 10));
MultiKeyUntyped multikey = EventBeanUtility.GetMultiKey(theEvent, getters);
Assert.AreEqual(2, multikey.Keys.Length);
Assert.AreEqual("a", multikey.Keys[0]);
Assert.AreEqual(10, multikey.Keys[1]);
// try no properties
multikey = EventBeanUtility.GetMultiKey(theEvent, new EventPropertyGetter[0]);
Assert.AreEqual(0, multikey.Keys.Length);
}
public void SetUp()
{
var aggregators = new SupportAggregatorFactory[2];
for (int i = 0; i < aggregators.Length; i++)
{
aggregators[i] = new SupportAggregatorFactory();
}
var evaluators = new[] { new SupportExprNode(5).ExprEvaluator, new SupportExprNode(2).ExprEvaluator };
_service = new AggSvcGroupByNoAccessImpl(evaluators, aggregators);
_groupOneKey = new MultiKeyUntyped(new Object[] { "x", "y1" });
_groupTwoKey = new MultiKeyUntyped(new Object[] { "x", "y2" });
}
/// <summary>
/// Returns number or bool computation for the target coercion type.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="coercedType">target type</param>
/// <returns>number cruncher</returns>
public static Computer GetComputer(this BitWiseOpEnum value, Type coercedType)
{
if ((coercedType != typeof(byte?)) &&
(coercedType != typeof(byte?)) &&
(coercedType != typeof(short?)) &&
(coercedType != typeof(int?)) &&
(coercedType != typeof(long?)) &&
(coercedType != typeof(bool?)))
{
throw new ArgumentException("Expected base numeric or bool type for computation result but got type " + coercedType);
}
MultiKeyUntyped key = new MultiKeyUntyped(new Object[] { coercedType, value });
return(Computers[key]);
}
public void TestIndex()
{
FilterParamIndexNotIn index = new FilterParamIndexNotIn(MakeLookupable("LongBoxed"), ReaderWriterLockManager.CreateDefaultLock());
Assert.AreEqual(FilterOperator.NOT_IN_LIST_OF_VALUES, index.FilterOperator);
index.Put(new MultiKeyUntyped(new Object[] { 2L, 5L }), _testEvaluators[0]);
index.Put(new MultiKeyUntyped(new Object[] { 3L, 4L, 5L }), _testEvaluators[1]);
index.Put(new MultiKeyUntyped(new Object[] { 1L, 4L, 5L }), _testEvaluators[2]);
index.Put(new MultiKeyUntyped(new Object[] { 2L, 5L }), _testEvaluators[3]);
Verify(index, 0L, new bool[] { true, true, true, true });
Verify(index, 1L, new bool[] { true, true, false, true });
Verify(index, 2L, new bool[] { false, true, true, false });
Verify(index, 3L, new bool[] { true, false, true, true });
Verify(index, 4L, new bool[] { true, false, false, true });
Verify(index, 5L, new bool[] { false, false, false, false });
Verify(index, 6L, new bool[] { true, true, true, true });
MultiKeyUntyped inList = new MultiKeyUntyped(new Object[] { 3L, 4L, 5L });
Assert.AreEqual(_testEvaluators[1], index.Get(inList));
Assert.IsTrue(index.ReadWriteLock != null);
Assert.IsTrue(index.Remove(inList));
Assert.IsFalse(index.Remove(inList));
Assert.AreEqual(null, index.Get(inList));
// now that {3,4,5} is removed, verify results again
Verify(index, 0L, new bool[] { true, false, true, true });
Verify(index, 1L, new bool[] { true, false, false, true });
Verify(index, 2L, new bool[] { false, false, true, false });
Verify(index, 3L, new bool[] { true, false, true, true });
Verify(index, 4L, new bool[] { true, false, false, true });
Verify(index, 5L, new bool[] { false, false, false, false });
Verify(index, 6L, new bool[] { true, false, true, true });
try
{
index["a"] = _testEvaluators[0];
Assert.IsTrue(false);
}
catch (Exception ex)
{
// Expected
}
}
private void Add(String key, EventBean theEvent)
{
((SupportBean)theEvent.Underlying).TheString = key;
var mkey = new MultiKeyUntyped(new Object[]
{
key
}
);
var eventList = (List <EventBean>)_sortedEvents.Get(mkey);
if (eventList == null)
{
eventList = new List <EventBean>();
}
eventList.Insert(0, theEvent);
_sortedEvents.Put(mkey, eventList);
}
public static EventBean[] Reorder(String[] keys, EventBean[] events)
{
var result = new EventBean[events.Length];
Array.Copy(events, 0, result, 0, result.Length);
var mkcomparator = new MultiKeyComparator(new bool[keys.Length]);
var comparer = new StandardComparer <EventBean>(
(o1, o2) =>
{
MultiKeyUntyped mk1 = GetMultiKey(o1, keys);
MultiKeyUntyped mk2 = GetMultiKey(o2, keys);
return(mkcomparator.Compare(mk1, mk2));
});
Array.Sort(result, comparer);
return(result);
}
public static Object GetLookupKey(Object[] lookupKeys)
{
Object key;
if (lookupKeys.Length == 0)
{
key = typeof(Object);
}
else if (lookupKeys.Length > 1)
{
key = new MultiKeyUntyped(lookupKeys);
}
else
{
key = lookupKeys[0];
}
return(key);
}
public void TestMixedEntryElement()
{
var list1 = new List <EventBean>();
list1.Add(_events.Get("a"));
var keyA = new MultiKeyUntyped(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 MultiKeyUntyped(
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 MultiKeyUntyped(
new Object[]
{
"keyC"
}
);
_testMap.Put(keyC, list3);
IEnumerator <EventBean> it = new SortWindowEnumerator(_testMap);
EPAssertionUtil.AssertEqualsExactOrder(
new EventBean[]
{
_events.Get("a"), _events.Get("c"), _events.Get("d"), _events.Get("e"),
_events.Get("f"), _events.Get("g")
}
, it);
}
public void MatchFound(EventBean theEvent, ICollection <FilterHandleCallback> allStmtMatches)
{
Object key;
if (_getters.Length > 1)
{
var keys = new Object[_getters.Length];
for (int i = 0; i < keys.Length; i++)
{
keys[i] = _getters[i].Get(theEvent);
}
key = new MultiKeyUntyped(keys);
}
else
{
key = _getters[0].Get(theEvent);
}
_callback.Create(key, theEvent);
}
public void TestOneElement()
{
var list = new List <EventBean>();
list.Add(_events.Get("a"));
var key = new MultiKeyUntyped(
new Object[]
{
"akey"
}
);
_testMap.Put(key, list);
IEnumerator <EventBean> it = new SortWindowEnumerator(_testMap);
EPAssertionUtil.AssertEqualsExactOrder(
new EventBean[]
{
_events.Get("a")
}
, it);
}
public ISet <EventBean> GetCollectKeys(EventBean[] eventsPerStream, DataMap parent, ExprEvaluatorContext context, IList <Object> keys)
{
EventBean[] eventsToUse;
if (_isNwOnTrigger)
{
eventsToUse = eventsPerStream;
}
else
{
Array.Copy(eventsPerStream, 0, _events, 1, eventsPerStream.Length);
eventsToUse = _events;
}
MultiKeyUntyped mk = EventBeanUtility.GetMultiKey(eventsToUse, _evaluators, context, _keyCoercionTypes);
keys.AddAll(mk.Keys);
var innerIndex = (DataMap)parent.Get(mk);
if (innerIndex == null)
{
return(null);
}
return(_next.GetCollectKeys(eventsPerStream, innerIndex, context, keys));
}
private IList <Object> CreateSortPropertiesWRollup(IList <GroupByRollupKey> currentGenerators, OrderByElement[][] elementsPerLevel, bool isNewData, AgentInstanceContext exprEvaluatorContext)
{
var sortProperties = new Object[currentGenerators.Count];
var elements = _factory.OrderBy;
if (elements.Length == 1)
{
var count = 0;
foreach (var rollup in currentGenerators)
{
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(rollup.GroupKey, exprEvaluatorContext.AgentInstanceId, rollup.Level);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(rollup.Generator, _factory.OrderBy);
}
sortProperties[count] = elementsPerLevel[rollup.Level.LevelNumber][0].Expr.Evaluate(
new EvaluateParams(rollup.Generator, isNewData, exprEvaluatorContext));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(sortProperties[count]);
}
count++;
}
}
else
{
var count = 0;
foreach (var rollup in currentGenerators)
{
var evaluateParams = new EvaluateParams(rollup.Generator, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(rollup.GroupKey, exprEvaluatorContext.AgentInstanceId, rollup.Level);
}
var values = new Object[_factory.OrderBy.Length];
var countTwo = 0;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(rollup.Generator, _factory.OrderBy);
}
foreach (var sortPair in elementsPerLevel[rollup.Level.LevelNumber])
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
sortProperties[count] = new MultiKeyUntyped(values);
count++;
}
}
return(sortProperties);
}
public EventBean DetermineLocalMinMax(EventBean[] outgoingEvents, EventBean[][] generatingEvents, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
// Get the group by keys if needed
Object[] groupByKeys = null;
if (_factory.IsNeedsGroupByKeys)
{
groupByKeys = GenerateGroupKeys(generatingEvents, isNewData, exprEvaluatorContext);
}
OrderByElement[] elements = _factory.OrderBy;
Object localMinMax = null;
EventBean outgoingMinMaxBean = null;
if (elements.Length == 1)
{
int count = 0;
foreach (EventBean[] eventsPerStream in generatingEvents)
{
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
var sortKey = elements[0].Expr.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(localMinMax);
}
var newMinMax = localMinMax == null || _factory.Comparator.Compare(localMinMax, sortKey) > 0;
if (newMinMax)
{
localMinMax = sortKey;
outgoingMinMaxBean = outgoingEvents[count];
}
count++;
}
}
else
{
var count = 0;
var values = new Object[_factory.OrderBy.Length];
var valuesMk = new MultiKeyUntyped(values);
foreach (var eventsPerStream in generatingEvents)
{
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
var countTwo = 0;
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
foreach (var sortPair in _factory.OrderBy)
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
var newMinMax = localMinMax == null || _factory.Comparator.Compare(localMinMax, valuesMk) > 0;
if (newMinMax)
{
localMinMax = valuesMk;
values = new Object[_factory.OrderBy.Length];
valuesMk = new MultiKeyUntyped(values);
outgoingMinMaxBean = outgoingEvents[count];
}
count++;
}
}
return(outgoingMinMaxBean);
}
/// <summary>Returns the set of events that have the same property value as the given event. </summary>
/// <param name="keys">to compare against</param>
/// <returns>set of events with property value, or null if none found (never returns zero-sized set)</returns>
public virtual ISet <EventBean> Lookup(object[] keys)
{
var key = new MultiKeyUntyped(keys);
return(PropertyIndex.Get(key));
}
/// <summary>
/// Returns number cruncher for the target coercion type.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="coercedType">target type</param>
/// <param name="typeOne">the LHS type</param>
/// <param name="typeTwo">the RHS type</param>
/// <param name="isIntegerDivision">false for division returns double, true for using standard integer division</param>
/// <param name="isDivisionByZeroReturnsNull">false for division-by-zero returns infinity, true for null</param>
/// <param name="optionalMathContext">The optional math context.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">
/// Expected base numeric type for computation result but got type + coercedType
/// or
/// Could not determine process or type + value + type + coercedType
/// or
/// Could not determine process or type + value + type + coercedType
/// </exception>
public static Computer GetComputer(this MathArithTypeEnum value, Type coercedType, Type typeOne, Type typeTwo, bool isIntegerDivision, bool isDivisionByZeroReturnsNull, MathContext optionalMathContext)
{
Type t = Nullable.GetUnderlyingType(coercedType);
if (t != null)
{
coercedType = t;
}
if ((coercedType != typeof(BigInteger)) &&
(coercedType != typeof(decimal)) &&
(coercedType != typeof(double)) &&
(coercedType != typeof(float)) &&
(coercedType != typeof(long)) &&
(coercedType != typeof(int)))
{
throw new ArgumentException("Expected base numeric type for computation result but got type " + coercedType);
}
if (value != MathArithTypeEnum.DIVIDE)
{
var key = new MultiKeyUntyped(new Object[] { coercedType, value });
var computer = Computers.Get(key);
if (computer == null)
{
throw new ArgumentException("Could not determine process or type " + value + " type " + coercedType);
}
return(computer);
}
if (!isIntegerDivision)
{
if (coercedType == typeof(decimal))
{
return(isDivisionByZeroReturnsNull ? (Computer)DivideDecimalChecked : DivideDecimalUnchecked);
}
return(isDivisionByZeroReturnsNull ? (Computer)DivideDoubleChecked : DivideDoubleUnchecked);
}
if (coercedType == typeof(BigInteger))
{
return(DivideBigInteger);
}
if (coercedType == typeof(double))
{
return(isDivisionByZeroReturnsNull ? (Computer)DivideDoubleChecked : DivideDoubleUnchecked);
}
if (coercedType == typeof(float))
{
return(DivideSingle);
}
if (coercedType == typeof(long))
{
return(DivideInt64);
}
if (coercedType == typeof(int))
{
return(DivideInt32);
}
if (coercedType == typeof(decimal))
{
return(isDivisionByZeroReturnsNull ? (Computer)DivideDecimalChecked : DivideDecimalUnchecked);
}
throw new ArgumentException("Could not determine process or type " + value + " type " + coercedType);
}
/// <summary>
/// Returns the set of events that have the same property value as the given event.
/// </summary>
/// <param name="keys">to compare against</param>
/// <returns>set of events with property value, or null if none found (never returns zero-sized set)</returns>
public override ISet <EventBean> Lookup(object[] keys)
{
var key = new MultiKeyUntyped(keys);
return(propertyIndex.Get(key));
}
