Пример #1
0
        public void AddObject(object obj, CollectionOperation op)
        {
            if (_excludeResults != null && _excludeResults.ContainsKey(obj))
            {
                return;
            }

            if (!(_resultKeys.ContainsKey(obj)))
            {
                _resultKeys[obj] = null;
                _wrappedResult.AddObject(obj, op);
            }
        }
Пример #2
0
        public void GetData(object key, ComparisonType comparisonType, IQueryResult result, CollectionOperation op, CancellationToken token)
        {
            IComparable keyToCompare = key as IComparable;

            if (_store != null)
            {
                switch (comparisonType)
                {
                case ComparisonType.EQUALS:
                    if (_store.Contains(key))
                    {
                        result.AddObject(_store[key], op);
                    }
                    break;

                case ComparisonType.NOT_EQUALS:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        if (((IComparable)storedKey).CompareTo(keyToCompare) != 0)
                        {
                            result.AddObject(_store[storedKey], op);
                        }
                    }
                    break;

                case ComparisonType.LESS_THAN:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        if (((IComparable)storedKey).CompareTo(keyToCompare) < 0)
                        {
                            result.AddObject(_store[storedKey], op);
                        }
                    }
                    break;

                case ComparisonType.GREATER_THAN:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        if (((IComparable)storedKey).CompareTo(keyToCompare) > 0)
                        {
                            result.AddObject(_store[storedKey], op);
                        }
                    }
                    break;

                case ComparisonType.LESS_THAN_EQUALS:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        if (((IComparable)storedKey).CompareTo(keyToCompare) <= 0)
                        {
                            result.AddObject(_store[storedKey], op);
                        }
                    }
                    break;

                case ComparisonType.GREATER_THAN_EQUALS:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        if (((IComparable)storedKey).CompareTo(keyToCompare) >= 0)
                        {
                            result.AddObject(_store[storedKey], op);
                        }
                    }
                    break;

                case ComparisonType.LIKE:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        string pattern             = key as string;
                        WildcardEnabledRegex regex = new WildcardEnabledRegex(pattern);

                        if (storedKey is string)
                        {
                            if (regex.IsMatch((string)storedKey))
                            {
                                result.AddObject(_store[storedKey], op);
                            }
                        }
                    }

                    break;

                case ComparisonType.NOT_LIKE:
                    foreach (object storedKey in _store.Keys)
                    {
                        if (token != null && token.IsCancellationRequested)
                        {
                            throw new OperationCanceledException(ExceptionsResource.OperationFailed);
                        }
                        string pattern             = key as string;
                        WildcardEnabledRegex regex = new WildcardEnabledRegex(pattern);

                        if (storedKey is string)
                        {
                            if (!regex.IsMatch((string)storedKey))
                            {
                                result.AddObject(_store[storedKey], op);
                            }
                        }
                    }

                    break;
                }
                result.Mark(op);
            }
        }