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); } } }