private ItemInfo registerSourceItem(TSourceItem sourceItem, int index, ItemInfo itemInfo = null)
{
itemInfo = itemInfo == null?_sourcePositions.Insert(index) : _itemInfos[index];
ExpressionWatcher watcher;
Utils.getItemInfoContent(
new object[] { sourceItem },
out watcher,
out Func <TResultItem> predicateFunc,
out List <IComputingInternal> nestedComputings,
_selectorExpression,
out _selectorExpressionСallCount,
this,
_selectorContainsParametrizedObservableComputationsCalls,
_selectorExpressionInfo);
itemInfo.SelectorFunc = predicateFunc;
itemInfo.NestedComputings = nestedComputings;
watcher.ValueChanged = expressionWatcher_OnValueChanged;
itemInfo.ExpressionWatcher = watcher;
watcher._position = itemInfo;
return(itemInfo);
}
private FilteringItemInfo registerSourceItem(TSourceItem sourceItem, int sourceIndex, Position position,
Position nextItemPosition, ExpressionWatcher watcher = null, Func <bool> predicateFunc = null,
List <IComputingInternal> nestedComputings = null)
{
FilteringItemInfo itemInfo = _sourcePositions.Insert(sourceIndex);
itemInfo.FilteredPosition = position;
itemInfo.NextFilteredItemPosition = nextItemPosition;
if (watcher == null /*&& predicateFunc == null*/)
{
Utils.getItemInfoContent(
new object[] { sourceItem },
out watcher,
out predicateFunc,
out nestedComputings,
_predicateExpression,
out _predicateExpressionCallCount,
this,
_predicateContainsParametrizedObservableComputationsCalls,
_predicateExpressionInfo);
}
itemInfo.PredicateFunc = predicateFunc;
watcher.ValueChanged = _thisAsFiltering.expressionWatcher_OnValueChanged;
watcher._position = itemInfo;
itemInfo.ExpressionWatcher = watcher;
itemInfo.NestedComputings = nestedComputings;
return(itemInfo);
}
void ISourceCollectionChangeProcessor.processSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
int newIndex = e.NewStartingIndex;
TSourceItem addedItem = (TSourceItem)e.NewItems[0];
registerSourceItem(addedItem, newIndex);
break;
case NotifyCollectionChangedAction.Remove:
unregisterSourceItem(e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Replace:
int replacingSourceIndex = e.NewStartingIndex;
TSourceItem replacingSourceItem = (TSourceItem)e.NewItems[0];
OrderingItemInfo <TOrderingValue> replacingItemInfo = _itemInfos[replacingSourceIndex];
ExpressionWatcher oldExpressionWatcher = replacingItemInfo.ExpressionWatcher;
Utils.disposeExpressionWatcher(oldExpressionWatcher, replacingItemInfo.NestedComputings, this,
_orderingValueSelectorContainsParametrizedLiveLinqCalls);
Utils.getItemInfoContent(
new object[] { replacingSourceItem },
out ExpressionWatcher newExpressionWatcher,
out Func <TOrderingValue> newGetOrderingValueFunc,
out List <IComputingInternal> nestedComputings,
_orderingValueSelectorExpression,
out _orderingValueSelectorExpressionCallCount,
this,
_orderingValueSelectorContainsParametrizedLiveLinqCalls,
_orderingValueSelectorExpressionInfo);
replacingItemInfo.GetOrderingValueFunc = newGetOrderingValueFunc;
replacingItemInfo.ExpressionWatcher = newExpressionWatcher;
replacingItemInfo.ExpressionWatcher.ValueChanged = expressionWatcher_OnValueChanged;
newExpressionWatcher._position = oldExpressionWatcher._position;
replacingItemInfo.NestedComputings = nestedComputings;
baseSetItem(replacingItemInfo.OrderedItemInfo.Index, replacingSourceItem);
processSourceItemChange(replacingSourceIndex, replacingSourceItem);
break;
case NotifyCollectionChangedAction.Move:
int oldStartingIndex = e.OldStartingIndex;
int newStartingIndex = e.NewStartingIndex;
if (oldStartingIndex != newStartingIndex)
{
_sourcePositions.Move(oldStartingIndex, newStartingIndex);
}
break;
case NotifyCollectionChangedAction.Reset:
processSource();
break;
}
}
private void registerSourceItem(TSourceItem sourceItem, int sourceIndex, bool initializing = false)
{
OrderingItemInfo <TOrderingValue> itemInfo = _sourcePositions.Insert(sourceIndex);
Utils.getItemInfoContent(
new object[] { sourceItem },
out ExpressionWatcher expressionWatcher,
out Func <TOrderingValue> getOrderingValueFunc,
out List <IComputingInternal> nestedComputings,
_orderingValueSelectorExpression,
out _orderingValueSelectorExpressionCallCount,
this,
_orderingValueSelectorContainsParametrizedLiveLinqCalls,
_orderingValueSelectorExpressionInfo);
itemInfo.GetOrderingValueFunc = getOrderingValueFunc;
itemInfo.ExpressionWatcher = expressionWatcher;
itemInfo.NestedComputings = nestedComputings;
TOrderingValue orderingValue = getOrderingValue(itemInfo, sourceItem);
int orderedIndex = getOrderedIndex(orderingValue);
itemInfo.ExpressionWatcher.ValueChanged = expressionWatcher_OnValueChanged;
itemInfo.ExpressionWatcher._position = itemInfo;
OrderedItemInfo <TOrderingValue> orderedItemInfo = _orderedPositions.Insert(orderedIndex);
itemInfo.OrderedItemInfo = orderedItemInfo;
orderedItemInfo.ItemInfo = itemInfo;
_orderingValues.Insert(orderedIndex, orderingValue);
if (_thenOrderingsCount > 0)
{
adjustEqualOrderingValueRangePosition(orderingValue, orderedItemInfo, orderedIndex, orderedIndex - 1, orderedIndex);
}
if (initializing)
{
_items.Insert(orderedIndex, sourceItem);
}
else
{
baseInsertItem(orderedIndex, sourceItem);
}
}
internal static bool ProcessReplaceSourceItem <TExpression, TSourceItem>(
FilteringItemInfo replacingItemInfo,
TSourceItem sourceItem,
object[] sourceItems,
int sourceIndex, bool predicateContainsParametrizedObservableComputationsCalls,
Expression <TExpression> predicateExpression,
out int predicateExpressionCallCount,
ExpressionWatcher.ExpressionInfo orderingValueSelectorExpressionInfo,
List <FilteringItemInfo> filteringItemInfos,
Positions <Position> filteredPositions, IFiltering <TSourceItem> thisAsFiltering,
CollectionComputing <TSourceItem> current)
{
ExpressionWatcher oldExpressionWatcher = replacingItemInfo.ExpressionWatcher;
Utils.disposeExpressionWatcher(oldExpressionWatcher, replacingItemInfo.NestedComputings, thisAsFiltering,
predicateContainsParametrizedObservableComputationsCalls);
Utils.getItemInfoContent(
sourceItems,
out ExpressionWatcher watcher,
out Func <bool> predicateFunc,
out List <IComputingInternal> nestedComputings1,
predicateExpression,
out predicateExpressionCallCount,
thisAsFiltering,
predicateContainsParametrizedObservableComputationsCalls,
orderingValueSelectorExpressionInfo);
replacingItemInfo.PredicateFunc = predicateFunc;
watcher.ValueChanged = thisAsFiltering.expressionWatcher_OnValueChanged;
watcher._position = oldExpressionWatcher._position;
replacingItemInfo.ExpressionWatcher = watcher;
replacingItemInfo.NestedComputings = nestedComputings1;
bool replace = !ProcessChangeSourceItem(sourceIndex, sourceItem, filteringItemInfos, thisAsFiltering,
filteredPositions, current) &&
replacingItemInfo.FilteredPosition != null;
return(replace);
}
private ItemInfo registerSourceItem(TSourceItem sourceItem, int sourceIndex)
{
ItemInfo itemInfo = _sourcePositions.Insert(sourceIndex);
Utils.getItemInfoContent(
new object[] { sourceItem },
out ExpressionWatcher watcher,
out Func <bool> predicateFunc,
out List <IComputingInternal> nestedComputings,
_predicateExpression,
out _predicateExpressionСallCount,
this,
_predicateContainsParametrizedObservableComputationCalls,
_predicateExpressionInfo);
itemInfo.PredicateFunc = predicateFunc;
watcher.ValueChanged = expressionWatcher_OnValueChanged;
watcher._position = itemInfo;
itemInfo.ExpressionWatcher = watcher;
itemInfo.NestedComputings = nestedComputings;
return(itemInfo);
}
void ISourceCollectionChangeProcessor.processSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
int newSourceIndex = e.NewStartingIndex;
TSourceItem addedSourceItem = (TSourceItem)e.NewItems[0];
Position newItemPosition = null;
Position nextItemPosition;
int?newFilteredIndex = null;
Utils.getItemInfoContent(
new object[] { addedSourceItem },
out ExpressionWatcher newWatcher,
out Func <bool> newPredicateFunc,
out List <IComputingInternal> nestedComputings,
_predicateExpression,
out _predicateExpressionCallCount,
this,
_predicateContainsParametrizedObservableComputationsCalls,
_predicateExpressionInfo);
bool predicateValue = _thisAsFiltering.applyPredicate(addedSourceItem, newPredicateFunc);
nextItemPosition = FilteringUtils.processAddSourceItem(newSourceIndex, predicateValue, ref newItemPosition,
ref newFilteredIndex, _itemInfos, _filteredPositions, Count);
registerSourceItem(addedSourceItem, newSourceIndex, newItemPosition, nextItemPosition, newWatcher,
newPredicateFunc, nestedComputings);
if (newFilteredIndex != null)
{
baseInsertItem(newFilteredIndex.Value, addedSourceItem);
}
break;
case NotifyCollectionChangedAction.Remove:
unregisterSourceItem(e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Move:
FilteringUtils.ProcessMoveSourceItems(e.OldStartingIndex, e.NewStartingIndex, _itemInfos,
_filteredPositions, _sourcePositions, this);
break;
case NotifyCollectionChangedAction.Reset:
processSource();
break;
case NotifyCollectionChangedAction.Replace:
int sourceIndex = e.NewStartingIndex;
TSourceItem replacingSourceItem = (TSourceItem)e.NewItems[0];
FilteringItemInfo replacingItemInfo = _itemInfos[sourceIndex];
bool replace = FilteringUtils.ProcessReplaceSourceItem(replacingItemInfo, replacingSourceItem,
new object[] { replacingSourceItem },
sourceIndex, _predicateContainsParametrizedObservableComputationsCalls, _predicateExpression,
out _predicateExpressionCallCount, _predicateExpressionInfo, _itemInfos, _filteredPositions,
_thisAsFiltering, this);
if (replace)
{
baseSetItem(replacingItemInfo.FilteredPosition.Index, replacingSourceItem);
}
break;
}
}
void ISourceCollectionChangeProcessor.processSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
int newSourceIndex = e.NewStartingIndex;
TSourceItem addedSourceItem = (TSourceItem)e.NewItems[0];
ItemInfo itemInfo = registerSourceItem(addedSourceItem, newSourceIndex);
if (applyPredicate(addedSourceItem, itemInfo.PredicateFunc))
{
_predicatePassedCount++;
itemInfo.PredicateResult = true;
}
calculateValue();
break;
case NotifyCollectionChangedAction.Remove:
int oldStartingIndex = e.OldStartingIndex;
if (_itemInfos[oldStartingIndex].PredicateResult)
{
_predicatePassedCount--;
}
unregisterSourceItem(oldStartingIndex);
calculateValue();
break;
case NotifyCollectionChangedAction.Move:
int newSourceIndex1 = e.NewStartingIndex;
int oldSourceIndex = e.OldStartingIndex;
if (newSourceIndex1 != oldSourceIndex)
{
_sourcePositions.Move(oldSourceIndex, newSourceIndex1);
}
break;
case NotifyCollectionChangedAction.Reset:
initializeFromSource();
break;
case NotifyCollectionChangedAction.Replace:
int newStartingIndex = e.NewStartingIndex;
ItemInfo replacingItemInfo = _itemInfos[newStartingIndex];
ExpressionWatcher oldExpressionWatcher = replacingItemInfo.ExpressionWatcher;
Utils.disposeExpressionWatcher(oldExpressionWatcher, replacingItemInfo.NestedComputings, this,
_predicateContainsParametrizedObservableComputationCalls);
if (replacingItemInfo.PredicateResult)
{
_predicatePassedCount--;
}
ExpressionWatcher watcher;
Func <bool> predicateFunc;
TSourceItem replacingSourceItem = (TSourceItem)e.NewItems[0];
Utils.getItemInfoContent(
new object[] { replacingSourceItem },
out watcher,
out predicateFunc,
out List <IComputingInternal> nestedComputings1,
_predicateExpression,
out _predicateExpressionСallCount,
this,
_predicateContainsParametrizedObservableComputationCalls,
_predicateExpressionInfo);
replacingItemInfo.PredicateFunc = predicateFunc;
watcher.ValueChanged = expressionWatcher_OnValueChanged;
watcher._position = oldExpressionWatcher._position;
replacingItemInfo.ExpressionWatcher = watcher;
replacingItemInfo.NestedComputings = nestedComputings1;
if (applyPredicate(replacingSourceItem, predicateFunc))
{
_predicatePassedCount++;
replacingItemInfo.PredicateResult = true;
}
else
{
replacingItemInfo.PredicateResult = false;
}
calculateValue();
break;
}
}