Пример #1
0
        internal void ValidateInternalConsistency()
        {
            _sourcePositions.ValidateInternalConsistency();
            IList <TSourceItem> source = _sourceScalar.getValue(_source, new ObservableCollection <TSourceItem>()) as IList <TSourceItem>;

            // ReSharper disable once PossibleNullReferenceException
            if (_itemInfos.Count != source.Count)
            {
                throw new ValidateInternalConsistencyException("Consistency violation: Selecting.1");
            }
            Func <TSourceItem, TResultItem> selector = _selectorExpressionOriginal.Compile();

            // ReSharper disable once ConditionIsAlwaysTrueOrFalse
            if (source != null)
            {
                if (_itemInfos.Count != source.Count)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: Selecting.6");
                }

                for (int sourceIndex = 0; sourceIndex < source.Count; sourceIndex++)
                {
                    TSourceItem sourceItem = source[sourceIndex];
                    ItemInfo    itemInfo   = _itemInfos[sourceIndex];

                    if (!EqualityComparer <TResultItem> .Default.Equals(this[sourceIndex], selector(sourceItem)))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Selecting.2");
                    }

                    if (_itemInfos[sourceIndex].Index != sourceIndex)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Selecting.3");
                    }
                    if (itemInfo.ExpressionWatcher._position != _itemInfos[sourceIndex])
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Selecting.4");
                    }

                    if (!_itemInfos.Contains((ItemInfo)itemInfo.ExpressionWatcher._position))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Selecting.5");
                    }

                    if (itemInfo.ExpressionWatcher._position.Index != sourceIndex)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Selecting.7");
                    }
                }
            }
        }
        internal void ValidateInternalConsistency()
        {
            _filteredPositions.ValidateInternalConsistency();
            _sourcePositions.ValidateInternalConsistency();

            IList <TSourceItem> source = _sourceScalar.getValue(_source, new ObservableCollection <TSourceItem>()) as IList <TSourceItem>;

            // ReSharper disable once PossibleNullReferenceException
            if (_itemInfos.Count != source.Count)
            {
                throw new ValidateInternalConsistencyException("Consistency violation: Filtering.9");
            }
            Func <TSourceItem, bool> predicate1 = _predicateExpression.Compile();
            Func <TSourceItem, FilteringItemInfo, bool> predicate = (si, fii) => fii.PredicateFunc != null?fii.PredicateFunc() : predicate1(si);

            // ReSharper disable once ConditionIsAlwaysTrueOrFalse
            if (source != null)
            {
                if (_itemInfos.Count != source.Count)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: Filtering.14");
                }

                if (_source != null && _filteredPositions.List.Count - 1 != Count)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: Filtering.15");
                }

                if (_source == null && _filteredPositions.List.Count != 0)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: Filtering.16");
                }

                int count = 0;
                int index = 0;
                for (int sourceIndex = 0; sourceIndex < source.Count; sourceIndex++)
                {
                    TSourceItem       sourceItem = source[sourceIndex];
                    FilteringItemInfo itemInfo   = _itemInfos[sourceIndex];
                    if (predicate(sourceItem, itemInfo))
                    {
                        if (itemInfo.FilteredPosition == null)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: Filtering.2");
                        }

                        if (!EqualityComparer <TSourceItem> .Default.Equals(this[index], sourceItem))
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: Filtering.1");
                        }

                        if (itemInfo.FilteredPosition.Index != index)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: Filtering.5");
                        }

                        count++;
                        index++;
                    }
                    else
                    {
                        if (itemInfo.FilteredPosition != null)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: Filtering.3");
                        }
                    }

                    if (_itemInfos[sourceIndex].Index != sourceIndex)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.7");
                    }
                    if (itemInfo.ExpressionWatcher._position != _itemInfos[sourceIndex])
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.8");
                    }

                    if (itemInfo.FilteredPosition != null && !_filteredPositions.List.Contains(itemInfo.FilteredPosition))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.10");
                    }

                    if (!_filteredPositions.List.Contains(itemInfo.NextFilteredItemPosition))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.11");
                    }

                    if (!_itemInfos.Contains(itemInfo.ExpressionWatcher._position))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.12");
                    }
                }

                if (_source != null)
                {
                    Position nextFilteredItemPosition = _filteredPositions.List[count];
                    for (int sourceIndex = source.Count - 1; sourceIndex >= 0; sourceIndex--)
                    {
                        TSourceItem       sourceItem = source[sourceIndex];
                        FilteringItemInfo itemInfo   = _itemInfos[sourceIndex];

                        if (itemInfo.NextFilteredItemPosition != nextFilteredItemPosition)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: Filtering.4");
                        }

                        if (predicate(sourceItem, itemInfo))
                        {
                            nextFilteredItemPosition = itemInfo.FilteredPosition;
                        }
                    }

                    if (_filteredPositions.List.Count != count + 1)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: Filtering.6");
                    }
                }
            }
        }
Пример #3
0
        internal void ValidateInternalConsistency()
        {
            _sourcePositions.ValidateInternalConsistency();
            IList <TSourceItem> source = _sourceScalar.getValue(_source, new ObservableCollection <TSourceItem>()) as IList <TSourceItem>;
            // ReSharper disable once PossibleNullReferenceException
            int sourceCount = source.Count;

            if (_itemInfos.Count != sourceCount)
            {
                throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.1");
            }
            Func <TSourceItem, bool> predicate = _predicateExpressionOriginal.Compile();
            int predicatePassedCount           = 0;

            // ReSharper disable once ConditionIsAlwaysTrueOrFalse
            if (source != null)
            {
                if (_sourcePositions.List.Count != sourceCount)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.9");
                }

                // ReSharper disable once NotAccessedVariable
                int index = 0;
                for (int sourceIndex = 0; sourceIndex < sourceCount; sourceIndex++)
                {
                    TSourceItem sourceItem = source[sourceIndex];
                    ItemInfo    itemInfo   = _itemInfos[sourceIndex];
                    if (predicate(sourceItem))
                    {
                        predicatePassedCount++;
                        index++;
                        if (!itemInfo.PredicateResult)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.2");
                        }
                    }
                    else
                    {
                        if (itemInfo.PredicateResult)
                        {
                            throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.3");
                        }
                    }

                    if (_sourcePositions.List[sourceIndex].Index != sourceIndex)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.4");
                    }
                    if (itemInfo.ExpressionWatcher._position != _sourcePositions.List[sourceIndex])
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.5");
                    }

                    if (!_sourcePositions.List.Contains((ItemInfo)itemInfo.ExpressionWatcher._position))
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.6");
                    }

                    if (itemInfo.ExpressionWatcher._position.Index != sourceIndex)
                    {
                        throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.10");
                    }
                }

                if (predicatePassedCount != _predicatePassedCount)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.7");
                }
                if (_value != _predicatePassedCount > 0)
                {
                    throw new ValidateInternalConsistencyException("Consistency violation: AnyComputing.8");
                }
            }
        }