protected FilterParamIndexDoubleRangeBase(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock, FilterOperator filterOperator) : base(filterOperator, lookupable) { Ranges = new OrderedDictionary <DoubleRange, EventEvaluator>(new DoubleRangeComparator()); _rangesNullEndpoints = new Dictionary <DoubleRange, EventEvaluator>(); _rangesRwLock = readWriteLock; }
public FilterSpecParamContextProp(FilterSpecLookupable lookupable, FilterOperator filterOperator, String contextPropertyName, EventPropertyGetter getter, Coercer numberCoercer) : base(lookupable, filterOperator) { _contextPropertyName = contextPropertyName; _getter = getter; _numberCoercer = numberCoercer; }
public FilterParamIndexIn(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock) : base(FilterOperator.IN_LIST_OF_VALUES, lookupable) { _constantsMap = new Dictionary <Object, IList <EventEvaluator> >().WithNullSupport(); _evaluatorsMap = new Dictionary <MultiKeyUntyped, EventEvaluator>(); _constantsMapRwLock = readWriteLock; }
/// <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> /// Ctor. /// </summary> /// <param name="lookupable">is the lookup-able</param> /// <param name="filterOperator">is expected to be the BOOLEAN_EXPR operator</param> /// <param name="exprNode">represents the boolean expression</param> /// <param name="taggedEventTypes">is null if the expression doesn't need other streams, or is filled with a ordered list of stream names and types</param> /// <param name="arrayEventTypes">is a map of name tags and event type per tag for repeat-expressions that generate an array of events</param> /// <param name="variableService">provides access to variables</param> /// <param name="tableService">The table service.</param> /// <param name="eventAdapterService">for creating event types and event beans</param> /// <param name="configurationInformation">The configuration information.</param> /// <param name="statementName">Name of the statement.</param> /// <param name="hasSubquery">if set to <c>true</c> [has subquery].</param> /// <param name="hasTableAccess">if set to <c>true</c> [has table access].</param> /// <exception cref="System.ArgumentException">Invalid filter operator for filter expression node</exception> /// <throws>IllegalArgumentException for illegal args</throws> public FilterSpecParamExprNode( FilterSpecLookupable lookupable, FilterOperator filterOperator, ExprNode exprNode, IDictionary <string, Pair <EventType, string> > taggedEventTypes, IDictionary <string, Pair <EventType, string> > arrayEventTypes, VariableService variableService, TableService tableService, EventAdapterService eventAdapterService, ConfigurationInformation configurationInformation, string statementName, bool hasSubquery, bool hasTableAccess) : base(lookupable, filterOperator) { if (filterOperator != FilterOperator.BOOLEAN_EXPRESSION) { throw new ArgumentException("Invalid filter operator for filter expression node"); } _exprNode = exprNode; _taggedEventTypes = taggedEventTypes; _arrayEventTypes = arrayEventTypes; _variableService = variableService; _tableService = tableService; _eventAdapterService = eventAdapterService; _useLargeThreadingProfile = configurationInformation.EngineDefaults.ExecutionConfig.ThreadingProfile == ConfigurationEngineDefaults.ThreadingProfile.LARGE; _hasFilterStreamSubquery = hasSubquery; _hasTableAccess = hasTableAccess; var visitor = new ExprNodeVariableVisitor(); exprNode.Accept(visitor); _hasVariable = visitor.HasVariables; }
/// <summary> /// Find an index that matches one of the filter parameters passed. /// The parameter type and index type match up if the property name and /// filter operator are the same for the index and the filter parameter. /// For instance, for a filter parameter of "count EQUALS 10", the index against property "count" with /// operator type EQUALS will be returned, if present. /// NOTE: The caller is expected to obtain locks, if necessary, on the collections passed in. /// NOTE: Doesn't match non-property based index - thus bool expressions don't get found and are always entered as a /// new index /// </summary> /// <param name="parameters">is the list of sorted filter parameters</param> /// <param name="indizes">is the collection of indexes</param> /// <returns> /// A matching pair of filter parameter and index, if any matches were found. Null if no matches were found. /// </returns> public static Pair<FilterValueSetParam, FilterParamIndexBase> FindIndex( ICollection<FilterValueSetParam> parameters, IList<FilterParamIndexBase> indizes) { foreach (FilterValueSetParam parameter in parameters) { FilterSpecLookupable lookupable = parameter.Lookupable; FilterOperator @operator = parameter.FilterOperator; foreach (FilterParamIndexBase index in indizes) { // if property-based index, we prefer this in matching if (index is FilterParamIndexLookupableBase) { var propBasedIndex = (FilterParamIndexLookupableBase) index; if ((lookupable.Equals(propBasedIndex.Lookupable)) && (@operator.Equals(propBasedIndex.FilterOperator))) { return new Pair<FilterValueSetParam, FilterParamIndexBase>(parameter, index); } } else if (index is FilterParamIndexBooleanExpr && parameters.Count == 1) { // if bool-expression then match only if this is the last parameter, // all others considered are higher order and sort ahead if (@operator.Equals(FilterOperator.BOOLEAN_EXPRESSION)) { return new Pair<FilterValueSetParam, FilterParamIndexBase>(parameter, index); } } } } return null; }
public void RegisterNonPropertyExpression( string statementName, EventType eventType, FilterSpecLookupable lookupable) { // default implementation, no action required }
/// <summary> /// Constructor. /// </summary> /// <param name="lookupable">is the lookupable</param> /// <param name="filterOperator">is the type of compare</param> /// <param name="resultEventAsName">is the name of the result event from which to get a property value to compare</param> /// <param name="resultEventIndex">index</param> /// <param name="resultEventProperty">is the name of the property to get from the named result event</param> /// <param name="isMustCoerce">indicates on whether numeric coercion must be performed</param> /// <param name="numberCoercer">interface to use to perform coercion</param> /// <param name="coercionType">indicates the numeric coercion type to use</param> /// <param name="statementName">Name of the statement.</param> /// <throws>ArgumentException if an operator was supplied that does not take a single constant value</throws> public FilterSpecParamEventPropIndexed(FilterSpecLookupable lookupable, FilterOperator filterOperator, String resultEventAsName, int resultEventIndex, String resultEventProperty, bool isMustCoerce, Coercer numberCoercer, Type coercionType, String statementName) : base(lookupable, filterOperator) { _resultEventAsName = resultEventAsName; _resultEventIndex = resultEventIndex; _resultEventProperty = resultEventProperty; _isMustCoerce = isMustCoerce; _numberCoercer = numberCoercer; _coercionType = coercionType; _statementName = statementName; if (filterOperator.IsRangeOperator()) { throw new ArgumentException("Illegal filter operator " + filterOperator + " supplied to " + "event property filter parameter"); } }
public FilterParamIndexDoubleRange(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock, FilterOperator filterOperator) : base(lookupable, readWriteLock, filterOperator) { if (!(filterOperator.IsRangeOperator())) { throw new ArgumentException("Invalid filter operator " + filterOperator); } }
public FilterParamIndexNotIn(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock) : base(FilterOperator.NOT_IN_LIST_OF_VALUES, lookupable) { _constantsMap = new Dictionary <object, ISet <EventEvaluator> >().WithNullSupport(); _filterValueEvaluators = new Dictionary <MultiKeyUntyped, EventEvaluator>(); _evaluatorsSet = new HashSet <EventEvaluator>(); _constantsMapRwLock = readWriteLock; }
public FilterSpecParamAdvancedIndexQuadTreePointRegion( FilterSpecLookupable lookupable, FilterOperator filterOperator, FilterSpecParamFilterForEvalDouble xEval, FilterSpecParamFilterForEvalDouble yEval) : base(lookupable, filterOperator) { _xEval = xEval; _yEval = yEval; }
public FilterSpecParamAdvancedIndexQuadTreeMXCIF(FilterSpecLookupable lookupable, FilterOperator filterOperator, FilterSpecParamFilterForEvalDouble xEval, FilterSpecParamFilterForEvalDouble yEval, FilterSpecParamFilterForEvalDouble widthEval, FilterSpecParamFilterForEvalDouble heightEval) : base(lookupable, filterOperator) { _xEval = xEval; _yEval = yEval; _widthEval = widthEval; _heightEval = heightEval; }
/// <summary>Constructor. </summary> /// <param name="lookupable">is the lookupable</param> /// <param name="filterOperator">is the type of compare</param> /// <param name="filterConstant">contains the value to match against the event's property value</param> /// <throws>ArgumentException if an operator was supplied that does not take a single constant value</throws> public FilterSpecParamConstant(FilterSpecLookupable lookupable, FilterOperator filterOperator, Object filterConstant) : base(lookupable, filterOperator) { _filterConstant = filterConstant; if (filterOperator.IsRangeOperator()) { throw new ArgumentException("Illegal filter operator " + filterOperator + " supplied to " + "constant filter parameter"); } }
private static FilterSpecParamExprNode MakeBooleanExprParam(ExprNode exprNode, FilterSpecCompilerArgs args) { bool hasSubselectFilterStream = DetermineSubselectFilterStream(exprNode); bool hasTableAccess = DetermineTableAccessFilterStream(exprNode); var lookupable = new FilterSpecLookupable( FilterSpecCompiler.PROPERTY_NAME_BOOLEAN_EXPRESSION, null, exprNode.ExprEvaluator.ReturnType); return new FilterSpecParamExprNode( lookupable, FilterOperator.BOOLEAN_EXPRESSION, exprNode, args.TaggedEventTypes, args.ArrayEventTypes, args.VariableService, args.TableService, args.EventAdapterService, args.ConfigurationInformation, args.StatementName, hasSubselectFilterStream, hasTableAccess); }
/// <summary>Constructor. </summary> /// <param name="lookupable">is the lookupable</param> /// <param name="filterOperator">is the type of range operator</param> /// <param name="min">is the begin point of the range</param> /// <param name="max">is the end point of the range</param> /// <throws>ArgumentException if an operator was supplied that does not take a double range value</throws> public FilterSpecParamRange(FilterSpecLookupable lookupable, FilterOperator filterOperator, FilterSpecParamRangeValue min, FilterSpecParamRangeValue max) : base(lookupable, filterOperator) { _min = min; _max = max; if (!(filterOperator.IsRangeOperator()) && (!filterOperator.IsInvertedRangeOperator())) { throw new ArgumentException("Illegal filter operator " + filterOperator + " supplied to " + "range filter parameter"); } }
public bool Equals(FilterSpecLookupable other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Expression.Equals(other.Expression) && Equals(other.ReturnType, ReturnType)); }
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); }
public FilterParamIndexCompare(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock, FilterOperator filterOperator) : base(filterOperator, lookupable) { _constantsMap = new OrderedDictionary <Object, EventEvaluator>(); _constantsMapRwLock = readWriteLock; if ((filterOperator != FilterOperator.GREATER) && (filterOperator != FilterOperator.GREATER_OR_EQUAL) && (filterOperator != FilterOperator.LESS) && (filterOperator != FilterOperator.LESS_OR_EQUAL)) { throw new ArgumentException("Invalid filter operator for index of " + filterOperator); } }
// expressions automatically coerce to the most upwards type // filters require the same type private static object HandleConstantsCoercion(FilterSpecLookupable lookupable, object constant) { var identNodeType = lookupable.ReturnType; if (!identNodeType.IsNumeric()) { return constant; // no coercion required, other type checking performed by expression this comes from } if (constant == null) // null constant type { return null; } if (!constant.GetType().CanCoerce(identNodeType)) { ThrowConversionError(constant.GetType(), identNodeType, lookupable.Expression); } var identNodeTypeBoxed = identNodeType.GetBoxedType(); return CoercerFactory.CoerceBoxed(constant, identNodeTypeBoxed); }
/// <summary> /// Determine among the passed in filter parameters any parameter that matches the given index on property name and /// filter operator type. Returns null if none of the parameters matches the index. /// </summary> /// <param name="parameters">is the filter parameter list</param> /// <param name="index">is a filter parameter constant value index</param> /// <returns>filter parameter, or null if no matching parameter found.</returns> public static FilterValueSetParam FindParameter( ICollection<FilterValueSetParam> parameters, FilterParamIndexBase index) { if (index is FilterParamIndexLookupableBase) { var propBasedIndex = (FilterParamIndexLookupableBase) index; FilterSpecLookupable indexLookupable = propBasedIndex.Lookupable; FilterOperator indexOperator = propBasedIndex.FilterOperator; foreach (FilterValueSetParam parameter in parameters) { FilterSpecLookupable lookupable = parameter.Lookupable; FilterOperator paramOperator = parameter.FilterOperator; if ((lookupable.Equals(indexLookupable)) && (paramOperator.Equals(indexOperator))) { return parameter; } } } else { foreach (FilterValueSetParam parameter in parameters) { FilterOperator paramOperator = parameter.FilterOperator; if (paramOperator.Equals(index.FilterOperator)) { return parameter; } } } return null; }
public void TestNodeGetSet() { FilterHandle exprOne = new SupportFilterHandle(); // Check pre-conditions Assert.IsTrue(_testNode.NodeRWLock != null); Assert.IsFalse(_testNode.Contains(exprOne)); Assert.AreEqual(0, _testNode.FilterCallbackCount); Assert.AreEqual(0, _testNode.Indizes.Count); Assert.IsTrue(_testNode.IsEmpty()); _testNode.Add(exprOne); // Check after add Assert.IsTrue(_testNode.Contains(exprOne)); Assert.AreEqual(1, _testNode.FilterCallbackCount); Assert.IsFalse(_testNode.IsEmpty()); // Add an indexOne EventType eventType = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean)); FilterSpecLookupable lookupable = new FilterSpecLookupable("IntPrimitive", eventType.GetGetter("IntPrimitive"), eventType.GetPropertyType("IntPrimitive"), false); FilterParamIndexBase indexOne = new SupportFilterParamIndex(lookupable); _testNode.Add(indexOne); // Check after add Assert.AreEqual(1, _testNode.Indizes.Count); Assert.AreEqual(indexOne, _testNode.Indizes.FirstOrDefault()); // Check removes Assert.IsTrue(_testNode.Remove(exprOne)); Assert.IsFalse(_testNode.IsEmpty()); Assert.IsFalse(_testNode.Remove(exprOne)); Assert.IsTrue(_testNode.Remove(indexOne)); Assert.IsFalse(_testNode.Remove(indexOne)); Assert.IsTrue(_testNode.IsEmpty()); }
public FilterParamIndexNotEquals(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock) : base(lookupable, readWriteLock, FilterOperator.NOT_EQUAL) { }
public FilterParamIndexEqualsIs(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock) : base(lookupable, readWriteLock, FilterOperator.IS) { }
/// <summary>Ctor. </summary> /// <param name="lookupable">stuff to use to interrogate</param> /// <param name="filterOperator">operator to apply</param> /// <param name="filterValue">value to look for</param> public FilterValueSetParamImpl(FilterSpecLookupable lookupable, FilterOperator filterOperator, Object filterValue) { _lookupable = lookupable; _filterOperator = filterOperator; _filterValue = filterValue; }
/// <summary>Constructor. </summary> /// <param name="filterOperator">is the type of comparison performed.</param> /// <param name="lookupable">is the lookupable</param> protected FilterParamIndexLookupableBase(FilterOperator filterOperator, FilterSpecLookupable lookupable) : base(filterOperator) { Lookupable = lookupable; }
protected FilterParamIndexEqualsBase(FilterSpecLookupable lookupable, IReaderWriterLock readWriteLock, FilterOperator filterOperator) : base(filterOperator, lookupable) { ConstantsMap = new Dictionary <Object, EventEvaluator>().WithNullSupport(); ConstantsMapRwLock = readWriteLock; }
/// <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())); } throw new ArgumentException("Cannot create filter index instance for filter operator " + filterOperator); }
protected FilterSpecParam(FilterSpecLookupable lookupable, FilterOperator filterOperator) { Lookupable = lookupable; FilterOperator = filterOperator; }
/// <summary> /// Ctor. /// </summary> /// <param name="lookupable">is the event property or function</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> /// <exception cref="ArgumentException">for illegal args</exception> public FilterSpecParamIn( FilterSpecLookupable lookupable, FilterOperator filterOperator, IList<FilterSpecParamInValue> listofValues) : base(lookupable, filterOperator) { _listOfValues = listofValues; foreach (FilterSpecParamInValue value in listofValues) { Type returnType = value.ReturnType; if (TypeHelper.IsCollectionMapOrArray(returnType)) { _hasCollMapOrArray = true; break; } } if (_hasCollMapOrArray) { _adders = new InValueAdder[listofValues.Count]; for (int i = 0; i < listofValues.Count; i++) { Type returnType = listofValues[0].ReturnType; if (returnType == null) { _adders[i] = InValueAdderPlain.INSTANCE; } else if (returnType.IsArray) { _adders[i] = InValueAdderArray.INSTANCE; } else if (returnType.IsGenericDictionary()) { _adders[i] = InValueAdderMap.INSTANCE; } else if (returnType.IsGenericCollection()) { _adders[i] = InValueAdderColl.INSTANCE; } else { _adders[i] = InValueAdderPlain.INSTANCE; } } } bool isAllConstants = true; foreach (FilterSpecParamInValue value in listofValues) { if (!value.IsConstant) { isAllConstants = false; break; } } if (isAllConstants) { _inListConstantsOnly = GetFilterValues(null, null); } 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> /// 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); }