public override INotificationResult Notify(IList <INotificationResult> sources)
{
var backParsed = (ICollectionChangedNotificationResult)sources[0];
if (HasEventSubscriber)
{
if (backParsed.IsReset)
{
OnCleared();
}
else
{
if (backParsed.RemovedItems != null && backParsed.RemovedItems.Count > 0)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, backParsed.RemovedItems, backParsed.OldItemsStartIndex));
}
if (backParsed.AddedItems != null && backParsed.AddedItems.Count > 0)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, backParsed.AddedItems, backParsed.NewItemsStartIndex));
}
if (backParsed.MovedItems != null && backParsed.MovedItems.Count > 0)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, backParsed.MovedItems, backParsed.NewItemsStartIndex, backParsed.OldItemsStartIndex));
}
}
}
return(CollectionChangedNotificationResult <T> .Transfer(backParsed, this));
}
private void NotifySource(CollectionChangedNotificationResult <TSource> sourceChange, List <TResult> added, List <TResult> removed)
{
foreach (var item in sourceChange.AllRemovedItems)
{
if (item != null)
{
var lambdaResult = lambdaInstances[item];
lambdaResult.Tag--;
removed.Add(lambdaResult.Value);
if (lambdaResult.Tag == 0)
{
lambdaInstances.Remove(item);
lambdaResult.Successors.Unset(this);
}
}
else if (nullLambda != null)
{
nullLambda.Tag--;
if (nullLambda.Tag == 0)
{
nullLambda.Successors.Unset(this);
nullLambda = null;
}
}
}
foreach (var item in sourceChange.AllAddedItems)
{
var lambdaResult = AttachItem(item);
added.Add(lambdaResult.Value);
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
if (sources.Count == 0)
{
OnCleared();
return(CollectionChangedNotificationResult <T> .Create(this, true));
}
else
{
var change = (ICollectionChangedNotificationResult)sources[0];
if (change.IsReset)
{
OnCleared();
}
else
{
if (change.RemovedItems != null)
{
OnRemoveItems(change.RemovedItems.Cast <T>());
}
if (change.AddedItems != null)
{
OnAddItems(change.AddedItems.Cast <T>());
}
}
return(CollectionChangedNotificationResult <T> .Transfer(change, this));
}
}
private void NotifySource(CollectionChangedNotificationResult <TItem> sourceChange, List <TItem> added, List <TItem> removed)
{
foreach (var item in sourceChange.AllRemovedItems)
{
var lambdaResult = lambdas[item];
Collection <TItem> sequence;
if (searchTree.TryGetValue(lambdaResult.Value, out sequence))
{
sequence.Remove(item);
if (sequence.Count == 0)
{
searchTree.Remove(lambdaResult.Value);
}
}
removed.Add(item);
if (lambdaResult.Tag.Count == 1)
{
lambdas.Remove(item);
lambdaResult.Successors.Unset(this);
}
else
{
lambdaResult.Tag = new Multiplicity <TItem>(lambdaResult.Tag.Item, lambdaResult.Tag.Count - 1);
}
}
foreach (var item in sourceChange.AllAddedItems)
{
AttachItem(item);
added.Add(item);
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TSource> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
var moved = notification.MovedItems;
foreach (ICollectionChangedNotificationResult change in sources)
{
if (change.IsReset)
{
OnCleared();
notification.TurnIntoReset();
return(notification);
}
if (change.AddedItems != null)
{
added.AddRange(SL.Cast <TSource>(change.AddedItems));
}
if (change.RemovedItems != null)
{
removed.AddRange(SL.Cast <TSource>(change.RemovedItems));
}
if (change.MovedItems != null)
{
moved.AddRange(SL.Cast <TSource>(change.MovedItems));
}
}
RaiseEvents(added, removed, moved);
return(notification);
}
private void NotifySource(CollectionChangedNotificationResult <TSource> sourceChange, List <TResult> added, List <TResult> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
var data = results[item];
var resultItems = data.Item;
if (data.Count == 1)
{
if (data.Notifiable != null)
{
data.Notifiable.Successors.Unset(this);
}
resultItems.Successors.Unset(this);
results.Remove(item);
}
else
{
results[item] = new Itemdata(data.Item, data.Notifiable, data.Count - 1);
}
removed.AddRange(resultItems.Value);
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
added.AddRange(AttachItem(item));
}
}
}
private void NotifySource2(CollectionChangedNotificationResult <TSource> change, List <TSource> added, List <TSource> removed)
{
if (change.RemovedItems != null)
{
var uniqueRemoved = new HashSet <TSource>(sourceItems.Comparer);
foreach (var item in change.RemovedItems)
{
if (RemoveItem(item))
{
uniqueRemoved.Add(item);
}
}
removed.AddRange(SL.Where(source, item => uniqueRemoved.Contains(item)));
}
if (change.AddedItems != null)
{
var uniqueAdded = new HashSet <TSource>(sourceItems.Comparer);
foreach (var item in change.AddedItems)
{
if (AddItem(item))
{
uniqueAdded.Add(item);
}
}
added.AddRange(SL.Where(source, item => uniqueAdded.Contains(item)));
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <INotifyGrouping <TKey, TItem> > .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
foreach (var change in sources)
{
if (change.Source == source)
{
var sourceChange = (ICollectionChangedNotificationResult <TItem>)change;
if (sourceChange.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
else
{
var keyChange = (IValueChangedNotificationResult <TKey>)change;
var tagged = (TaggedObservableValue <TKey, TItem>)keyChange.Source;
ObservableGroup <TKey, TItem> group;
if (groups.TryGetValue(keyChange.OldValue, out group))
{
group.Items.Remove(tagged.Tag);
if (group.Count == 0)
{
groups.Remove(keyChange.OldValue);
removed.Add(group);
}
}
if (!groups.TryGetValue(keyChange.NewValue, out group))
{
group = new ObservableGroup <TKey, TItem>(keyChange.NewValue);
groups.Add(keyChange.NewValue, group);
added.Add(group);
}
group.Items.Add(tagged.Tag);
}
}
if (added.Count == 0 && removed.Count == 0)
{
return(UnchangedNotificationResult.Instance);
}
OnRemoveItems(removed.Cast <ObservableGroup <TKey, TItem> >());
OnAddItems(added.Cast <ObservableGroup <TKey, TItem> >());
return(notification);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TResult> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
foreach (var change in sources)
{
if (change.Source == source)
{
var sourceChange = (ICollectionChangedNotificationResult <TSource>)change;
if (sourceChange.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
else
{
var innerCollectionChange = change as ICollectionChangedNotificationResult;
if (innerCollectionChange != null)
{
if (innerCollectionChange.AddedItems != null)
{
added.AddRange(innerCollectionChange.AddedItems.Cast <TResult>());
}
if (innerCollectionChange.RemovedItems != null)
{
removed.AddRange(innerCollectionChange.RemovedItems.Cast <TResult>());
}
}
else
{
var subSourceChange = (IValueChangedNotificationResult <IEnumerable <TResult> >)change;
if (subSourceChange.OldValue != null)
{
removed.AddRange(subSourceChange.OldValue);
}
if (subSourceChange.NewValue != null)
{
added.AddRange(subSourceChange.NewValue);
}
}
}
}
OnRemoveItems(removed);
OnAddItems(added);
return(notification);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TItem> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
var moved = notification.MovedItems;
foreach (var change in sources)
{
if (change.Source == source)
{
var sourceChange = (ICollectionChangedNotificationResult <TItem>)change;
if (sourceChange.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
else
{
var lambdaResult = (TaggedObservableValue <TKey, SequenceInfo>)change.Source;
var searchTree = lambdaResult.Tag.SearchTree;
var keyChange = (IValueChangedNotificationResult <TKey>)change;
Collection <TItem> itemSequence;
if (searchTree.TryGetValue(keyChange.OldValue, out itemSequence))
{
itemSequence.Remove(lambdaResult.Tag.Item);
if (itemSequence.Count == 0)
{
searchTree.Remove(keyChange.OldValue);
}
}
if (!searchTree.TryGetValue(keyChange.NewValue, out itemSequence))
{
itemSequence = new Collection <TItem>();
searchTree.Add(keyChange.NewValue, itemSequence);
}
itemSequence.Add(lambdaResult.Tag.Item);
moved.Add(lambdaResult.Tag.Item);
}
}
OnRemoveItems(removed);
OnAddItems(added);
OnMoveItems(moved);
return(notification);
}
public Notifiable(IModelElement element)
{
this.element = element;
this.successors = new MultiSuccessorList();
this.metadata = new ExecutionMetaData();
this.notification = CollectionChangedNotificationResult <IModelElement> .Create(this, false);
element.BubbledChange += Element_BubbledChange;
}
public INotificationResult Notify(IList <INotificationResult> sources)
{
isNotified = false;
var result = notification;
notification = CollectionChangedNotificationResult <IModelElement> .Create(this, false);
return(result);
}
public INotificationResult Notify(IList <INotificationResult> sources)
{
INotificationResult result = new CollectionChangedNotificationResult <IModelElement>(this, added, removed);
isNotified = false;
added = null;
removed = null;
return(result);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TItem> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
var moved = notification.MovedItems;
foreach (var change in sources)
{
if (change.Source == source)
{
var sourceChange = (ICollectionChangedNotificationResult <TItem>)change;
if (sourceChange.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
else
{
var tagged = (TaggedObservableValue <TKey, Multiplicity <TItem> >)change.Source;
var keyChange = (IValueChangedNotificationResult <TKey>)change;
Collection <TItem> sequence;
if (searchTree.TryGetValue(keyChange.OldValue, out sequence))
{
sequence.Remove(tagged.Tag.Item);
if (sequence.Count == 0)
{
searchTree.Remove(keyChange.OldValue);
}
}
if ((sources.Count == 1 || !removed.Contains(tagged.Tag.Item)))
{
if (!searchTree.TryGetValue(keyChange.NewValue, out sequence))
{
sequence = new Collection <TItem>();
searchTree.Add(keyChange.NewValue, sequence);
}
sequence.Add(tagged.Tag.Item);
moved.Add(tagged.Tag.Item);
}
}
}
RaiseEvents(added, removed, moved);
return(notification);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
if (ShouldRecompute(sources))
{
Recompute();
return(CollectionChangedNotificationResult <IEnumerable <T> > .Create(this, isReset : true));
}
else
{
return(UnchangedNotificationResult.Instance);
}
}
private void NotifySource(CollectionChangedNotificationResult <TSource> sourceChange, List <TResult> added, List <TResult> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
SubSourcePair wrapper;
if (sourceItems.TryGetValue(item, out wrapper))
{
removed.AddRange(wrapper);
wrapper.Successors.Unset(this);
sourceItems.Remove(item);
}
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
var subSource = func.Observe(item);
var wrapper = new SubSourcePair(subSource, item, this);
wrapper.Successors.Set(this);
sourceItems.Add(item, wrapper);
added.AddRange(wrapper);
}
}
if (sourceChange.ReplaceAddedItems != null)
{
for (int i = 0; i < sourceChange.ReplaceAddedItems.Count; i++)
{
var oldItem = sourceChange.ReplaceRemovedItems[i];
var newItem = sourceChange.ReplaceAddedItems[i];
var newSubSource = func.Observe(newItem);
SubSourcePair wrapper;
if (sourceItems.TryGetValue(oldItem, out wrapper))
{
removed.AddRange(SL.Select(wrapper.Results.Values, res => res.Value));
wrapper.Successors.Unset(this);
sourceItems.Remove(oldItem);
}
wrapper = new SubSourcePair(newSubSource, newItem, this);
sourceItems.Add(newItem, wrapper);
wrapper.Successors.Set(this);
added.AddRange(SL.Select(wrapper.Results.Values, res => res.Value));
}
}
}
public Notifiable(IModelElement element)
{
this.element = element;
this.successors = new MultiSuccessorList();
this.metadata = new ExecutionMetaData();
this.notification = CollectionChangedNotificationResult <IModelElement> .Create(this, false);
element.ParentChanged += Ancestor_ParentChanged;
foreach (var ancestor in this)
{
ancestor.ParentChanged += Ancestor_ParentChanged;
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TSource> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
var moved = notification.MovedItems;
foreach (ICollectionChangedNotificationResult change in sources)
{
if (change.IsReset)
{
OnCleared();
notification.TurnIntoReset();
return(notification);
}
var offset = change.Source == source ? 0 : SL.Count(source);
if (change.AddedItems != null)
{
added.AddRange(SL.Cast <TSource>(change.AddedItems));
if (change.NewItemsStartIndex != -1)
{
notification.UpdateNewStartIndex(offset + change.NewItemsStartIndex);
}
}
if (change.RemovedItems != null)
{
removed.AddRange(SL.Cast <TSource>(change.RemovedItems));
if (change.OldItemsStartIndex != -1)
{
notification.UpdateOldStartIndex(offset + change.OldItemsStartIndex);
}
}
if (change.MovedItems != null)
{
moved.AddRange(SL.Cast <TSource>(change.MovedItems));
if (change.NewItemsStartIndex != -1)
{
notification.UpdateNewStartIndex(offset + change.NewItemsStartIndex);
}
if (change.OldItemsStartIndex != -1)
{
notification.UpdateOldStartIndex(offset + change.OldItemsStartIndex);
}
}
}
RaiseEvents(added, removed, moved, notification.OldItemsStartIndex, notification.NewItemsStartIndex);
return(notification);
}
private void NotifySource(CollectionChangedNotificationResult <TItem> sourceChange, List <INotifyGrouping <TKey, TItem> > added, List <INotifyGrouping <TKey, TItem> > removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
var group = DetachItem(item);
if (groups.ContainsValue(group))
{
added.Add(group);
}
removed.Add(group);
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
var add = AttachItem(item);
var group = groups[keys[item].Value];
if (!add)
{
removed.Add(group);
}
added.Add(group);
}
}
if (sourceChange.ReplaceAddedItems != null)
{
for (int i = 0; i < sourceChange.ReplaceAddedItems.Count; i++)
{
var oldItem = sourceChange.ReplaceRemovedItems[i];
var newItem = sourceChange.ReplaceAddedItems[i];
if (!ReplaceItem(oldItem, newItem))
{
var removedGroup = DetachItem(oldItem);
if (!groups.ContainsValue(removedGroup))
{
removed.Add(removedGroup);
}
if (AttachItem(newItem))
{
added.Add(groups[keys[newItem].Value]);
}
}
}
}
}
private void NotifySource(CollectionChangedNotificationResult <T> sourceChange, List <T> added, List <T> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
if (isValueType || item != null)
{
TaggedObservableValue <bool, ItemMultiplicity> lambdaResult;
if (lambdaInstances.TryGetValue(item, out lambdaResult))
{
if (lambdaResult.Value)
{
removed.Add(lambdaResult.Tag.Item);
}
lambdaResult.Tag = lambdaResult.Tag.Decrease();
if (lambdaResult.Tag.Multiplicity == 0)
{
lambdaResult.Successors.Unset(this);
lambdaInstances.Remove(item);
}
}
}
else
{
nulls--;
if (nulls == 0)
{
nullCheck.Successors.Unset(this);
nullCheck = null;
}
removed.Add(default(T));
}
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
var lambdaResult = AttachItem(item);
if (lambdaResult.Value)
{
added.Add(item);
}
}
}
}
private void NotifySource(CollectionChangedNotificationResult <TSource> change, List <TSource> added, List <TSource> removed)
{
foreach (var item in change.AllRemovedItems)
{
if (sourceItems.ContainsKey(item))
{
removed.Add(item);
}
}
foreach (var item in change.AllAddedItems)
{
if (sourceItems.ContainsKey(item))
{
added.Add(item);
}
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var change = (ICollectionChangedNotificationResult <TSource>)sources[0];
if (change.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
return(CollectionChangedNotificationResult <TSource> .Create(this, true));
}
var notification = CollectionChangedNotificationResult <TSource> .Create(this);
var removed = notification.RemovedItems;
var added = notification.AddedItems;
if (change.RemovedItems != null)
{
foreach (var item in change.RemovedItems)
{
if (RemoveItem(item))
{
removed.Add(item);
}
}
}
if (change.AddedItems != null)
{
foreach (var item in change.AddedItems)
{
if (AddItem(item))
{
added.Add(item);
}
}
}
OnRemoveItems(removed);
OnAddItems(added);
return(notification);
}
private void NotifySource2(CollectionChangedNotificationResult <T> change)
{
if (change.IsReset)
{
List <T> toRemove = new List <T>();
foreach (var entry in entries)
{
entry.Value.Source2Count = 0;
if (entry.Value.Source1Count == 0)
{
toRemove.Add(entry.Key);
}
}
foreach (var item in toRemove)
{
entries.Remove(item);
}
OnResetSource2(entries.Count);
foreach (var item in source2)
{
AddSource2(item);
}
}
else
{
if (change.RemovedItems != null)
{
foreach (var item in change.RemovedItems)
{
RemoveSource2(item);
}
}
if (change.AddedItems != null)
{
foreach (var item in change.AddedItems)
{
AddSource2(item);
}
}
}
}
void SequencesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (e.Action != NotifyCollectionChangedAction.Reset)
{
var notification = CollectionChangedNotificationResult <T> .Create(this);
var removed = notification.RemovedItems;
var added = notification.AddedItems;
if (e.OldItems != null)
{
foreach (IEnumerable <T> sequence in e.OldItems)
{
removed.AddRange(sequence);
INotifyCollectionChanged notifier = sequence as INotifyCollectionChanged;
if (notifier != null)
{
var listener = changeListener[sequence];
listener.Unsubscribe();
changeListener.Remove(sequence);
}
}
}
if (e.NewItems != null)
{
foreach (IEnumerable <T> sequence in e.NewItems)
{
added.AddRange(sequence);
INotifyCollectionChanged notifier = sequence as INotifyCollectionChanged;
if (notifier != null)
{
var listener = new CollectionChangeListener <T>(this);
listener.Subscribe(notifier);
changeListener.Add(sequence, listener);
}
}
}
ExecutionMetaData.Results.Add(notification);
}
ExecutionEngine.Current.InvalidateNode(this);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TResult> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
foreach (var change in sources)
{
if (change.Source == source)
{
var sourceChange = (ICollectionChangedNotificationResult <TSource>)change;
if (sourceChange.IsReset)
{
OnDetach();
OnAttach();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
else
{
var subSourceChange = (ICollectionChangedNotificationResult <TResult>)change;
if (subSourceChange.RemovedItems != null)
{
removed.AddRange(subSourceChange.RemovedItems);
}
if (subSourceChange.AddedItems != null)
{
added.AddRange(subSourceChange.AddedItems);
}
}
}
RaiseEvents(added, removed, null);
return(notification);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var notification = CollectionChangedNotificationResult <TResult> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
foreach (var change in sources)
{
if (change.Source == SubSource)
{
var subSourceChange = (IValueChangedNotificationResult)change;
DetachSubSourceValue((IEnumerable <TIntermediate>)subSourceChange.OldValue, removed);
OnAttach();
added.AddRange(SL.Select(Results.Values, res => res.Value));
}
else if (change.Source is TaggedObservableValue <TResult, int> )
{
var resultChange = (IValueChangedNotificationResult <TResult>)change;
removed.Add(resultChange.OldValue);
added.Add(resultChange.NewValue);
}
else
{
var subSourceValueChange = (ICollectionChangedNotificationResult <TIntermediate>)change;
if (subSourceValueChange.IsReset)
{
DetachSubSourceValue(SubSource.Value, removed);
AttachSubSourceValue();
added.AddRange(SL.Select(Results.Values, res => res.Value));
}
else
{
NotifySubSourceValue(added, removed, subSourceValueChange);
}
}
}
RaiseEvents(added, removed, null);
return(notification);
}
private void NotifyOuter(CollectionChangedNotificationResult <TOuter> outerChange, List <TResult> added, List <TResult> removed)
{
if (outerChange.RemovedItems != null)
{
foreach (var outer in outerChange.RemovedItems)
{
var valueStack = outerValues[outer];
var value = valueStack.Pop();
if (valueStack.Count == 0)
{
outerValues.Remove(outer);
}
var group = groups[value.Value];
var result = group.OuterElements[value];
if (group.InnerKeys.Count == 0)
{
if (group.OuterElements.Count == 0)
{
groups.Remove(value.Value);
}
}
else
{
removed.Add(result.Value);
}
group.OuterElements.Remove(value);
value.Successors.Unset(this);
result.Successors.Unset(this);
}
}
if (outerChange.AddedItems != null)
{
foreach (var outer in outerChange.AddedItems)
{
added.Add(AttachOuter(outer));
}
}
}
private void NotifySource(CollectionChangedNotificationResult <TItem> sourceChange, List <TItem> added, List <TItem> removed)
{
foreach (var item in sourceChange.AllRemovedItems)
{
var searchTree = lambdaResults[item].Peek().Tag.SearchTree;
DetachItem(searchTree, item);
}
removed.AddRange(sourceChange.AllRemovedItems);
foreach (var item in sourceChange.AllAddedItems)
{
var sequence = source.GetSequenceForItem(item);
SortedDictionary <TKey, Collection <TItem> > searchTree;
if (!searchTrees.TryGetValue(sequence, out searchTree))
{
searchTree = new SortedDictionary <TKey, Collection <TItem> >(comparer);
searchTrees.Add(sequence, searchTree);
}
AttachItem(searchTree, item);
}
added.AddRange(sourceChange.AllAddedItems);
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var change = (ICollectionChangedNotificationResult)sources[0];
if (change.IsReset)
{
OnCleared();
return(CollectionChangedNotificationResult <T> .Create(this, true));
}
var notification = CollectionChangedNotificationResult <T> .Create(this);
var removed = notification.RemovedItems;
var added = notification.AddedItems;
var moved = notification.MovedItems;
removed.AddRange(change.RemovedItems.OfType <T>());
added.AddRange(change.AddedItems.OfType <T>());
moved.AddRange(change.MovedItems.OfType <T>());
RaiseEvents(added, removed, moved);
return(notification);
}
private void NotifyInner(CollectionChangedNotificationResult <TInner> innerChange, List <TResult> added, List <TResult> removed)
{
if (innerChange.RemovedItems != null)
{
foreach (var inner in innerChange.RemovedItems)
{
var valueStack = innerValues[inner];
var value = valueStack.Pop();
if (valueStack.Count == 0)
{
innerValues.Remove(inner);
}
var group = groups[value.Value];
group.InnerKeys.Remove(value);
if (group.InnerKeys.Count == 0)
{
if (group.OuterElements.Count == 0)
{
groups.Remove(value.Value);
}
else
{
removed.AddRange(group.OuterElements.Values.Select(r => r.Value));
}
}
value.Successors.Unset(this);
}
}
if (innerChange.AddedItems != null)
{
foreach (var inner in innerChange.AddedItems)
{
AttachInner(inner, added);
}
}
}
