public void TestLongHighEndpointIncluded()
{
FilterParamIndexDoubleRange index = this.GetLongDataset(FilterOperator.RANGE_HALF_CLOSED);
VerifyLongPrimitive(index, -1, 0);
VerifyLongPrimitive(index, 0, 0);
VerifyLongPrimitive(index, 1, 2);
VerifyLongPrimitive(index, 2, 5);
VerifyLongPrimitive(index, 3, 5);
VerifyLongPrimitive(index, 4, 6);
VerifyLongPrimitive(index, 5, 6);
VerifyLongPrimitive(index, 6, 3);
VerifyLongPrimitive(index, 7, 5);
VerifyLongPrimitive(index, 8, 4);
VerifyLongPrimitive(index, 9, 5);
VerifyLongPrimitive(index, 10, 3);
VerifyLongPrimitive(index, 11, 1);
}
public void TestLongLowEndpointIncluded()
{
FilterParamIndexDoubleRange index = this.GetLongDataset(FilterOperator.RANGE_HALF_OPEN);
VerifyLongPrimitive(index, -1, 0);
VerifyLongPrimitive(index, 0, 2);
VerifyLongPrimitive(index, 1, 5);
VerifyLongPrimitive(index, 2, 5);
VerifyLongPrimitive(index, 3, 6);
VerifyLongPrimitive(index, 4, 6);
VerifyLongPrimitive(index, 5, 3);
VerifyLongPrimitive(index, 6, 5);
VerifyLongPrimitive(index, 7, 4);
VerifyLongPrimitive(index, 8, 5);
VerifyLongPrimitive(index, 9, 3);
VerifyLongPrimitive(index, 10, 1);
VerifyLongPrimitive(index, 11, 1);
}
public void TestDoubleBothEndpointsIncluded()
{
FilterParamIndexDoubleRange index = this.GetDoubleDataset(FilterOperator.RANGE_CLOSED);
VerifyDoublePrimitive(index, 1.49, 0);
VerifyDoublePrimitive(index, 1.5, 1);
VerifyDoublePrimitive(index, 2.5, 1);
VerifyDoublePrimitive(index, 2.51, 0);
VerifyDoublePrimitive(index, 3.5, 2);
VerifyDoublePrimitive(index, 4.4, 2);
VerifyDoublePrimitive(index, 4.5, 2);
VerifyDoublePrimitive(index, 4.5001, 1);
VerifyDoublePrimitive(index, 5.1, 1);
VerifyDoublePrimitive(index, 5.8, 2);
VerifyDoublePrimitive(index, 6.7, 2);
VerifyDoublePrimitive(index, 6.8, 1);
VerifyDoublePrimitive(index, 9.5, 1);
VerifyDoublePrimitive(index, 10.1, 0);
}
private FilterParamIndexDoubleRange GetLongDataset(FilterOperator operatorType)
{
FilterParamIndexDoubleRange index = MakeOne("LongPrimitive", operatorType, testEventType);
AddToIndex(index, 0, 5);
AddToIndex(index, 0, 6);
AddToIndex(index, 1, 3);
AddToIndex(index, 1, 5);
AddToIndex(index, 1, 7);
AddToIndex(index, 3, 5);
AddToIndex(index, 3, 7);
AddToIndex(index, 6, 9);
AddToIndex(index, 6, 10);
AddToIndex(index, 6, Int32.MaxValue - 1);
AddToIndex(index, 7, 8);
AddToIndex(index, 8, 9);
AddToIndex(index, 8, 10);
return(index);
}
public void TestDoubleVariableRangeSize()
{
FilterParamIndexDoubleRange index = MakeOne("DoublePrimitive", FilterOperator.RANGE_CLOSED, testEventType);
for (int i = 0; i < 100; i++)
{
DoubleRange range = new DoubleRange(i, i * 2);
index.Put(range, testEvaluator);
}
// 1 to 2
// 2 to 4
// 3 to 6
// and so on
VerifyDoublePrimitive(index, 1, 1);
VerifyDoublePrimitive(index, 2, 2);
VerifyDoublePrimitive(index, 2.001, 1);
VerifyDoublePrimitive(index, 3, 2);
VerifyDoublePrimitive(index, 4, 3);
VerifyDoublePrimitive(index, 4.5, 2);
VerifyDoublePrimitive(index, 50, 26);
}
/// <summary>
/// Factory for indexes that store filter parameter constants for a given event property and filter
/// operator.
/// <para />
/// Does not perform any check of validity of property name.
/// </summary>
/// <param name="filterOperator">is the type of index to use</param>
/// <param name="lockFactory">lock factory</param>
/// <param name="lookupable">the lookup item</param>
/// <returns>the proper index based on the filter operator type</returns>
public static FilterParamIndexBase CreateIndex(
ExprFilterSpecLookupable lookupable,
FilterServiceGranularLockFactory lockFactory,
FilterOperator filterOperator)
{
FilterParamIndexBase index;
var returnValueType = lookupable.ReturnType;
// Handle all EQUAL comparisons
if (filterOperator == FilterOperator.EQUAL) {
index = new FilterParamIndexEquals(lookupable, lockFactory.ObtainNew());
return index;
}
// Handle all NOT-EQUAL comparisons
if (filterOperator == FilterOperator.NOT_EQUAL) {
index = new FilterParamIndexNotEquals(lookupable, lockFactory.ObtainNew());
return index;
}
if (filterOperator == FilterOperator.IS) {
index = new FilterParamIndexEqualsIs(lookupable, lockFactory.ObtainNew());
return index;
}
if (filterOperator == FilterOperator.IS_NOT) {
index = new FilterParamIndexNotEqualsIs(lookupable, lockFactory.ObtainNew());
return index;
}
// Handle all GREATER, LESS etc. comparisons
if (filterOperator == FilterOperator.GREATER ||
filterOperator == FilterOperator.GREATER_OR_EQUAL ||
filterOperator == FilterOperator.LESS ||
filterOperator == FilterOperator.LESS_OR_EQUAL) {
if (returnValueType != typeof(string)) {
index = new FilterParamIndexCompare(lookupable, lockFactory.ObtainNew(), filterOperator);
}
else {
index = new FilterParamIndexCompareString(lookupable, lockFactory.ObtainNew(), filterOperator);
}
return index;
}
// Handle all normal and inverted RANGE comparisons
if (filterOperator.IsRangeOperator()) {
if (returnValueType != typeof(string)) {
index = new FilterParamIndexDoubleRange(lookupable, lockFactory.ObtainNew(), filterOperator);
}
else {
index = new FilterParamIndexStringRange(lookupable, lockFactory.ObtainNew(), filterOperator);
}
return index;
}
if (filterOperator.IsInvertedRangeOperator()) {
if (returnValueType != typeof(string)) {
return new FilterParamIndexDoubleRangeInverted(lookupable, lockFactory.ObtainNew(), filterOperator);
}
return new FilterParamIndexStringRangeInverted(lookupable, lockFactory.ObtainNew(), filterOperator);
}
// Handle all IN and NOT IN comparisons
if (filterOperator == FilterOperator.IN_LIST_OF_VALUES) {
return new FilterParamIndexIn(lookupable, lockFactory.ObtainNew());
}
if (filterOperator == FilterOperator.NOT_IN_LIST_OF_VALUES) {
return new FilterParamIndexNotIn(lookupable, lockFactory.ObtainNew());
}
// Handle re-usable boolean expression
if (filterOperator == FilterOperator.REBOOL) {
if (lookupable.ReturnType == null) {
return new FilterParamIndexReboolNoValue(lookupable, lockFactory.ObtainNew());
}
return new FilterParamIndexReboolWithValue(lookupable, lockFactory.ObtainNew());
}
// Handle all boolean expression
if (filterOperator == FilterOperator.BOOLEAN_EXPRESSION) {
return new FilterParamIndexBooleanExpr(lockFactory.ObtainNew());
}
// Handle advanced-index
if (filterOperator == FilterOperator.ADVANCED_INDEX) {
var advLookable = (FilterSpecLookupableAdvancedIndex) lookupable;
if (advLookable.IndexType.Equals(SettingsApplicationDotMethodPointInsideRectangle.INDEXTYPE_NAME)) {
return new FilterParamIndexQuadTreePointRegion(lockFactory.ObtainNew(), lookupable);
}
if (advLookable.IndexType.Equals(SettingsApplicationDotMethodRectangeIntersectsRectangle.INDEXTYPE_NAME)) {
return new FilterParamIndexQuadTreeMXCIF(lockFactory.ObtainNew(), lookupable);
}
throw new IllegalStateException("Unrecognized index type " + advLookable.IndexType);
}
throw new ArgumentException("Cannot create filter index instance for filter operator " + filterOperator);
}
private void AddToIndex(FilterParamIndexDoubleRange index, double min, double max)
{
DoubleRange r = new DoubleRange(min, max);
index.Put(r, testEvaluator);
}
