public FilterParamIndexQuadTreeMXCIF(IReaderWriterLock readWriteLock, FilterSpecLookupable lookupable)
: base(FilterOperator.ADVANCED_INDEX, lookupable)
{
_readWriteLock = readWriteLock;
_advancedIndex = (FilterSpecLookupableAdvancedIndex) lookupable;
var quadTreeConfig = _advancedIndex.QuadTreeConfig;
_quadTree = MXCIFQuadTreeFactory<object>.Make(
quadTreeConfig.X,
quadTreeConfig.Y,
quadTreeConfig.Width,
quadTreeConfig.Height);
}
private static FilterSpecParam HandleAdvancedIndexDescProvider(
FilterSpecCompilerAdvIndexDescProvider provider,
IDictionary <string, Pair <EventType, string> > arrayEventTypes,
string statementName,
ExprEvaluatorContext exprEvaluatorContext)
{
var filterDesc = provider.FilterSpecDesc;
if (filterDesc == null)
{
return(null);
}
var keyExpressions = filterDesc.KeyExpressions;
var xGetter = ResolveFilterIndexRequiredGetter(filterDesc.IndexName, keyExpressions[0]);
var yGetter = ResolveFilterIndexRequiredGetter(filterDesc.IndexName, keyExpressions[1]);
var widthGetter = ResolveFilterIndexRequiredGetter(filterDesc.IndexName, keyExpressions[2]);
var heightGetter = ResolveFilterIndexRequiredGetter(filterDesc.IndexName, keyExpressions[3]);
var config = (AdvancedIndexConfigContextPartitionQuadTree)filterDesc.IndexSpec;
var builder = new StringWriter();
ExprNodeUtility.ToExpressionString(keyExpressions[0], builder);
builder.Write(",");
ExprNodeUtility.ToExpressionString(keyExpressions[1], builder);
builder.Write(",");
ExprNodeUtility.ToExpressionString(keyExpressions[2], builder);
builder.Write(",");
ExprNodeUtility.ToExpressionString(keyExpressions[3], builder);
builder.Write("/");
builder.Write(filterDesc.IndexName.ToLower());
builder.Write("/");
builder.Write(filterDesc.IndexType.ToLower());
builder.Write("/");
config.ToConfiguration(builder);
var expression = builder.ToString();
Type returnType;
switch (filterDesc.IndexType)
{
case EngineImportApplicationDotMethodPointInsideRectangle.INDEX_TYPE_NAME:
returnType = typeof(XYPoint);
break;
case EngineImportApplicationDotMethodRectangeIntersectsRectangle.INDEX_TYPE_NAME:
returnType = typeof(XYWHRectangle);
break;
default:
throw new IllegalStateException("Unrecognized index type " + filterDesc.IndexType);
}
var lookupable = new FilterSpecLookupableAdvancedIndex(expression, null, returnType, config, xGetter, yGetter, widthGetter, heightGetter, filterDesc.IndexType);
var indexExpressions = filterDesc.IndexExpressions;
var xEval = ResolveFilterIndexDoubleEval(filterDesc.IndexName, indexExpressions[0], arrayEventTypes, statementName, exprEvaluatorContext);
var yEval = ResolveFilterIndexDoubleEval(filterDesc.IndexName, indexExpressions[1], arrayEventTypes, statementName, exprEvaluatorContext);
switch (filterDesc.IndexType)
{
case EngineImportApplicationDotMethodPointInsideRectangle.INDEX_TYPE_NAME:
return(new FilterSpecParamAdvancedIndexQuadTreePointRegion(lookupable, FilterOperator.ADVANCED_INDEX, xEval, yEval));
case EngineImportApplicationDotMethodRectangeIntersectsRectangle.INDEX_TYPE_NAME:
var widthEval = ResolveFilterIndexDoubleEval(filterDesc.IndexName, indexExpressions[2], arrayEventTypes, statementName, exprEvaluatorContext);
var heightEval = ResolveFilterIndexDoubleEval(filterDesc.IndexName, indexExpressions[3], arrayEventTypes, statementName, exprEvaluatorContext);
return(new FilterSpecParamAdvancedIndexQuadTreeMXCIF(lookupable, FilterOperator.ADVANCED_INDEX, xEval, yEval, widthEval, heightEval));
default:
throw new IllegalStateException("Unrecognized index type " + filterDesc.IndexType);
}
}
/// <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="lookupable">The lookupable.</param>
/// <param name="lockFactory">The lock factory.</param>
/// <param name="filterOperator">is the type of index to use</param>
/// <returns>
/// the proper index based on the filter operator type
/// </returns>
/// <exception cref="System.ArgumentException">Cannot create filter index instance for filter operator + filterOperator</exception>
public static FilterParamIndexBase CreateIndex(
FilterSpecLookupable lookupable,
FilterServiceGranularLockFactory lockFactory,
FilterOperator filterOperator)
{
FilterParamIndexBase index;
Type 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));
}
else
{
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 all bool expression
if (filterOperator == FilterOperator.BOOLEAN_EXPRESSION)
{
return(new FilterParamIndexBooleanExpr(lockFactory.ObtainNew()));
}
// Handle advanced-index
if (filterOperator == FilterOperator.ADVANCED_INDEX)
{
FilterSpecLookupableAdvancedIndex advLookable = (FilterSpecLookupableAdvancedIndex)lookupable;
if (advLookable.IndexType.Equals(EngineImportApplicationDotMethodPointInsideRectangle.INDEX_TYPE_NAME))
{
return(new FilterParamIndexQuadTreePointRegion(lockFactory.ObtainNew(), lookupable));
}
else if (advLookable.IndexType.Equals(EngineImportApplicationDotMethodRectangeIntersectsRectangle.INDEX_TYPE_NAME))
{
return(new FilterParamIndexQuadTreeMXCIF(lockFactory.ObtainNew(), lookupable));
}
else
{
throw new IllegalStateException("Unrecognized index type " + advLookable.IndexType);
}
}
throw new ArgumentException("Cannot create filter index instance for filter operator " + filterOperator);
}
