private void NotifySource(ICollectionChangedNotificationResult <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);
}
}
}
private void NotifySource2(ICollectionChangedNotificationResult <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)));
}
}
private void NotifySource(ICollectionChangedNotificationResult <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 NotifySource(ICollectionChangedNotificationResult <TItem> sourceChange, List <TItem> added, List <TItem> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
var searchTree = lambdaResults[item].Peek().Tag.SearchTree;
DetachItem(searchTree, item);
}
removed.AddRange(sourceChange.RemovedItems);
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
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.AddedItems);
}
}
private void RootElementsChanged(ICollectionChangedNotificationResult e)
{
if (e.IsReset)
{
nodes.Clear();
foreach (var node in incElements)
{
GetOrCreate(node, true);
}
}
else
{
if (e.RemovedItems != null)
{
//throw new NotImplementedException();
}
if (e.AddedItems != null)
{
foreach (T newNode in e.AddedItems)
{
GetOrCreate(newNode, true);
}
}
}
}
private void NotifyInner(ICollectionChangedNotificationResult <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 && group.OuterKeys.Count == 0)
{
groups.Remove(value.Value);
}
foreach (var outer in group.OuterKeys)
{
removed.Add(DetachResult(group, outer.Tag, inner));
}
value.Successors.Unset(this);
}
}
if (innerChange.AddedItems != null)
{
foreach (var inner in innerChange.AddedItems)
{
AttachInner(inner, added);
}
}
}
public static CollectionChangedNotificationResult <T> Transfer(ICollectionChangedNotificationResult oldResult, INotifiable newSource)
{
var result = Create(newSource);
result.AddedItems.AddRange(Cast(oldResult.AddedItems));
result.RemovedItems.AddRange(Cast(oldResult.RemovedItems));
result.MovedItems.AddRange(Cast(oldResult.MovedItems));
result.isReset = oldResult.IsReset;
return(result);
}
private void NotifySource(ICollectionChangedNotificationResult <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(ICollectionChangedNotificationResult <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]);
// }
// }
//}
}
internal void HandleIncidentsChanged(ICollectionChangedNotificationResult e)
{
if (!e.IsReset)
{
if (e.RemovedItems != null)
{
foreach (T item in e.RemovedItems)
{
RemoveEdgeTo(item);
}
}
if (e.AddedItems != null)
{
lock (holm)
{
foreach (T item in e.AddedItems)
{
AddEdgeTo(item);
}
}
}
}
else
{
lock (holm)
{
foreach (var edge in Incidents.Values)
{
edge.Count--;
edge.opposite.Count--;
if (edge.Count == 0)
{
edge.Cut();
edge.Target.Incidents.Remove(value);
}
}
Incidents.Clear();
foreach (var item in IncIncidents)
{
AddEdgeTo(item);
}
}
}
}
public static CollectionChangedNotificationResult <T> Transfer(ICollectionChangedNotificationResult oldResult, INotifiable newSource)
{
if (oldResult.IsReset)
{
return(new CollectionChangedNotificationResult <T>(newSource));
}
var orig = oldResult as CollectionChangedNotificationResult <T>;
if (orig != null)
{
return(new CollectionChangedNotificationResult <T>(newSource, orig.AddedItems, orig.RemovedItems, orig.MovedItems));
}
return(new CollectionChangedNotificationResult <T>(newSource,
Cast(oldResult.AddedItems),
Cast(oldResult.RemovedItems),
Cast(oldResult.MovedItems)));
}
private void NotifySource2(ICollectionChangedNotificationResult <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);
}
}
}
}
private void NotifyOuter(ICollectionChangedNotificationResult <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(ICollectionChangedNotificationResult <TItem> sourceChange, List <TItem> added, List <TItem> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
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);
}
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
AttachItem(item);
added.Add(item);
}
}
}
private void NotifySource(ICollectionChangedNotificationResult <TSource> change, List <TSource> added, List <TSource> removed)
{
if (change.RemovedItems != null)
{
foreach (var item in change.RemovedItems)
{
if (sourceItems.ContainsKey(item))
{
removed.Add(item);
}
}
}
if (change.AddedItems != null)
{
foreach (var item in change.AddedItems)
{
if (sourceItems.ContainsKey(item))
{
added.Add(item);
}
}
}
}
private bool HandleSourceCollectionChange(ICollectionChangedNotificationResult <T> collectionChange)
{
var anyChanges = false;
if (collectionChange.IsReset)
{
throw new NotSupportedException();
}
if (collectionChange.RemovedItems != null)
{
foreach (var item in collectionChange.RemovedItems)
{
if (_keyDictionary.TryGetValue(item, out var notifiable))
{
var index = _keys.BinarySearch(notifiable.Value, _keyComparer);
if (index >= 0)
{
_keys.RemoveAt(index);
_items.RemoveAt(index);
anyChanges = true;
}
_keyDictionary.Remove(item);
_keyDictionaryInverse.Remove(notifiable);
notifiable.Successors.Unset(this);
}
}
}
if (collectionChange.AddedItems != null)
{
foreach (var item in collectionChange.AddedItems)
{
anyChanges |= AddItem(item);
}
}
return(anyChanges);
}
private void NotifySubSourceValue(List <TResult> added, List <TResult> removed, ICollectionChangedNotificationResult <TIntermediate> subSourceValueChange)
{
if (subSourceValueChange.RemovedItems != null)
{
foreach (var element in subSourceValueChange.RemovedItems)
{
removed.Add(Results[element].Value);
DetachResult(element);
}
}
if (subSourceValueChange.AddedItems != null)
{
foreach (var element in subSourceValueChange.AddedItems)
{
AttachResult(element);
added.Add(Results[element].Value);
}
}
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
ICollectionChangedNotificationResult <TSource> sourceChange = null;
ICollectionChangedNotificationResult <TSource> source2Change = null;
if (sources[0].Source == source)
{
sourceChange = (ICollectionChangedNotificationResult <TSource>)sources[0];
}
else
{
source2Change = (ICollectionChangedNotificationResult <TSource>)sources[0];
}
if (sources.Count > 1)
{
if (sources[1].Source == source)
{
sourceChange = (ICollectionChangedNotificationResult <TSource>)sources[1];
}
else
{
source2Change = (ICollectionChangedNotificationResult <TSource>)sources[1];
}
}
var notification = CollectionChangedNotificationResult <TSource> .Create(this);
var added = notification.AddedItems;
var removed = notification.RemovedItems;
if (source2Change != null)
{
if (source2Change.IsReset)
{
sourceItems.Clear();
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource2(source2Change, added, removed);
}
}
if (sourceChange != null)
{
if (sourceChange.IsReset)
{
OnCleared();
notification.TurnIntoReset();
return(notification);
}
else
{
NotifySource(sourceChange, added, removed);
}
}
OnRemoveItems(removed);
OnAddItems(added);
return(notification);
}
private void NotifySource(ICollectionChangedNotificationResult <TSource> sourceChange, List <TResult> added, List <TResult> removed, bool checkConflicts)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
if (item != null)
{
var lambdaResult = lambdaInstances[item];
lambdaResult.Tag--;
if (checkConflicts)
{
var addIndex = added.IndexOf(lambdaResult.Value);
if (addIndex != -1)
{
added.RemoveAt(addIndex);
}
else
{
removed.Add(lambdaResult.Value);
}
}
else
{
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;
}
}
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
var lambdaResult = AttachItem(item);
if (checkConflicts)
{
var removeIndex = removed.IndexOf(lambdaResult.Value);
if (removeIndex != -1)
{
removed.RemoveAt(removeIndex);
}
else
{
added.Add(lambdaResult.Value);
}
}
else
{
added.Add(lambdaResult.Value);
}
}
}
}
