public void SetUp()
{
_serverUpdateStream = new Subject<Either<FullUpdate, DeltaUpdate>>();
_dictionaryModificationStream = _serverUpdateStream
.Select(either =>
{
if (either.IsLeft)
{
return DictionaryModification.Replace(either.Left.Values["key"], (Update)either.Left);
}
else
{
return DictionaryModification.Upset(either.Right.Values["key"], (Update)either.Right);
}
});
_observableDictionary = _dictionaryModificationStream.ToObservableDictionary((key, existing, update) =>
{
var fullUpdate = new FullUpdate(key)
{
Values = new Dictionary<string, string>(existing.Values)
};
foreach (var kvp in update)
{
fullUpdate.Values[kvp.Key] = kvp.Value;
}
return fullUpdate;
});
}
public void SetUp()
{
_serverUpdateStream = new Subject <Either <FullUpdate, DeltaUpdate> >();
_dictionaryModificationStream = _serverUpdateStream
.Select(either =>
{
if (either.IsLeft)
{
return(DictionaryModification.Replace(either.Left.Values["key"], (Update)either.Left));
}
else
{
return(DictionaryModification.Upset(either.Right.Values["key"], (Update)either.Right));
}
});
_observableDictionary = _dictionaryModificationStream.ToObservableDictionary((key, existing, update) =>
{
var fullUpdate = new FullUpdate(key)
{
Values = new Dictionary <string, string>(existing.Values)
};
foreach (var kvp in update)
{
fullUpdate.Values[kvp.Key] = kvp.Value;
}
return(fullUpdate);
});
}
/// <summary>
/// Forwards the <paramref name="source" /> changes to the <paramref name="target" />.
/// </summary>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="source">The source observable dictionary.</param>
/// <param name="target">The target <see cref="IEnhancedBindingList{TValue}"/>.</param>
/// <param name="dictionaryChangesFilterPredicate">A filter function to test each <paramref name="source" /> change for whether or not to forward it to the <paramref name="target" />.</param>
/// <param name="includeItemChanges">if set to <c>true</c> individual items' changes will be propagated to the <paramref name="target" />.</param>
/// <param name="addRangePredicateForResets">This filter predicate tests which elements of the source <see cref="IObservableDictionary{TKey,TValue}"/> to add
/// whenever a <see cref="ObservableDictionaryChangeType.Reset"/> is received. A reset is forwarded by clearing the <paramref name="target"/> completely and re-filling it with
/// the source's values, and this predicate determines which ones are added. If no filter predicate is provided, all source values will be re-added to the <paramref name="target"/>.</param>
/// <param name="addDistinctValuesOnResetOnly">if set to <c>true</c> only distinct values will be re-added on <see cref="ObservableDictionaryChangeType.Reset" /> changes.</param>
/// <param name="valueComparerForResets">The value equality comparer to use for reset changes and if <paramref name="valueComparerForResets"/> is set to [true]. If none is provided, the default one for the value type will be used</param>
/// <param name="scheduler">The scheduler to schedule notifications and changes on.</param>
/// <returns>An <see cref="IDisposable"/> which will forward the changes to the <paramref name="target"/> as long as <see cref="IDisposable.Dispose"/> hasn't been called.</returns>
public static IDisposable ForwardDictionaryChangesTo <TKey, TValue>(
this IObservableDictionary <TKey, TValue> source,
IEnhancedBindingList <TValue> target,
Func <IObservableDictionaryChange <TKey, TValue>, bool> dictionaryChangesFilterPredicate,
bool includeItemChanges = false,
Func <KeyValuePair <TKey, TValue>, bool> addRangePredicateForResets = null,
bool addDistinctValuesOnResetOnly = true,
IEqualityComparer <TValue> valueComparerForResets = null,
IScheduler scheduler = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
var sourceObservable = scheduler != null
? source.DictionaryChanges.ObserveOn(scheduler)
: source.DictionaryChanges;
if (dictionaryChangesFilterPredicate != null)
{
sourceObservable = sourceObservable.Where(dictionaryChangesFilterPredicate);
}
return(sourceObservable.ForwardDictionaryChangesTo(target, includeItemChanges, addRangePredicateForResets, addDistinctValuesOnResetOnly, valueComparerForResets));
}
private void DeregisterRunResultsEvents(IRun run)
{
IObservableDictionary <string, IItem> dict = run.Results;
dict.ItemsAdded -= RunOnResultChanged;
dict.ItemsRemoved -= RunOnResultRemoved;
dict.ItemsReplaced -= RunOnResultChanged;
dict.CollectionReset -= RunOnResultChanged;
}
private void RegisterRunParametersEvents(IRun run)
{
IObservableDictionary <string, IItem> dict = run.Parameters;
dict.ItemsAdded += RunOnParameterChanged;
dict.ItemsRemoved += RunOnParameterRemoved;
dict.ItemsReplaced += RunOnParameterChanged;
dict.CollectionReset += RunOnParameterChanged;
}
public ReadOnlyObservableDictionary(IObservableDictionary <TKey, TValue> dictionary)
{
if (dictionary == null)
{
throw new ArgumentNullException();
}
dict = dictionary;
RegisterEvents();
}
/// <summary>
/// Forwards the <paramref name="source" /> changes to the <paramref name="target" />.
/// </summary>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="source">The source observable dictionary.</param>
/// <param name="target">The target <see cref="IEnhancedBindingList{TValue}"/>.</param>
/// <param name="includeItemChanges">if set to <c>true</c> individual items' changes will be propagated to the <paramref name="target" />.</param>
/// <param name="scheduler">The scheduler to schedule notifications and changes on.</param>
/// <returns>An <see cref="IDisposable"/> which will forward the changes to the <paramref name="target"/> as long as <see cref="IDisposable.Dispose"/> hasn't been called.</returns>
public static IDisposable ForwardDictionaryChangesTo <TKey, TValue>(
this IObservableDictionary <TKey, TValue> source,
IEnhancedBindingList <TValue> target,
bool includeItemChanges = false,
IScheduler scheduler = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
var sourceObservable = scheduler != null
? source.DictionaryChanges.ObserveOn(scheduler)
: source.DictionaryChanges;
return(sourceObservable.ForwardDictionaryChangesTo(target, includeItemChanges));
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableDictionaryChange{TKey,TValue}" /> class.
/// </summary>
/// <param name="dictionary">The dictionary for this change.</param>
/// <param name="changeType">Type of the change.</param>
/// <param name="key">The key of the changed value.</param>
/// <param name="value">The added, removed or changed, new value.</param>
/// <param name="oldValue">The replaced value, only applicable if <paramref name="changeType" /> is <see cref="ObservableDictionaryChangeType.ItemValueReplaced" />.</param>
/// <param name="changedPropertyName">The changed property name, only applicable if <paramref name="changeType" /> is <see cref="ObservableDictionaryChangeType.ItemValueChanged" />.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// $Item Adds, Key-/Value Changes or Removes must have a (non-default) '{nameof(key)}'
/// or
/// $Resets must not have a '{nameof(value)}'
/// or
/// $Only Changes may have a '{nameof(oldValue)}'
/// or
/// $Only '{ObservableDictionaryChangeType.ItemValueChanged}' and '{ObservableDictionaryChangeType.ItemKeyChanged}' Changes may have a '{nameof(changedPropertyName)}'
/// </exception>
protected ObservableDictionaryChange(IObservableDictionary <TKey, TValue> dictionary, ObservableDictionaryChangeType changeType, TKey key = default(TKey), TValue value = default(TValue), TValue oldValue = default(TValue), string changedPropertyName = "")
{
if (dictionary == null)
{
throw new ArgumentNullException(nameof(dictionary));
}
if ((changeType != ObservableDictionaryChangeType.Reset && changeType != ObservableDictionaryChangeType.ItemValueChanged) &&
(KeyIsValueType.Value == false && Equals(key, default(TKey))))
{
throw new ArgumentOutOfRangeException(nameof(key), $"Item Adds, Key-/Value Changes or Removes must have a (non-default) '{nameof(key)}'");
}
if (changeType == ObservableDictionaryChangeType.Reset && (ValueIsValueType.Value == false && !Equals(value, default(TValue))))
{
throw new ArgumentOutOfRangeException(nameof(value), $"Resets must not have a '{nameof(value)}'");
}
if (changeType != ObservableDictionaryChangeType.ItemValueReplaced &&
(ValueIsValueType.Value == false && !Equals(oldValue, default(TValue))))
{
throw new ArgumentOutOfRangeException(nameof(oldValue), $"Only Changes may have a '{nameof(oldValue)}'");
}
if (changeType != ObservableDictionaryChangeType.ItemValueChanged && changeType != ObservableDictionaryChangeType.ItemKeyChanged && !string.IsNullOrWhiteSpace(changedPropertyName))
{
throw new ArgumentOutOfRangeException(nameof(changedPropertyName), $"Only '{ObservableDictionaryChangeType.ItemValueChanged}' and '{ObservableDictionaryChangeType.ItemKeyChanged}' Changes may have a '{nameof(changedPropertyName)}'");
}
Dictionary = dictionary;
ChangeType = changeType;
Key = key;
Value = value;
OldValue = oldValue;
ChangedPropertyName = changedPropertyName ?? string.Empty;
}
/// <inheritdoc />
public void Init()
{
_currencies = new ObservableDictionary <GameId, int>(Data.Currencies);
}
/// <inheritdoc />
public void Init()
{
Ids = new ObservableDictionary <UniqueId, GameId>(Data.GameIds);
}
/// <summary>${WP_pubilc_Constructors_Initializes} <see cref="ElementsLayer">ElementsLayer</see>
/// ${WP_pubilc_Constructors_instance}</summary>
public ElementsLayer()
{
Children = new ObservableCollection<UIElement>();
Children.CollectionChanged += new NotifyCollectionChangedEventHandler(children_CollectionChanged);
IsAutoAvoidance = false;
BoundsCollection = new TObservableDictionary<object, Rectangle2D>();
}
/// <summary>
/// Converts the given <paramref name="observableDictionaryChange" /> to its <see cref="IObservableCollectionChange{T}" /> counterpart.
/// </summary>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="observableDictionaryChange">The observable dictionary change.</param>
/// <param name="dictionary">The sender <see cref="IObservableDictionary{TKey,TValue}" />.</param>
/// <param name="valueComparer">The <typeparamref name="TValue"/> equality comparer.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">observableDictionaryChange</exception>
/// <exception cref="System.ArgumentOutOfRangeException">$Only {ObservableDictionaryChangeType.ItemAdded}, {ObservableDictionaryChangeType.ItemValueChanged}, {ObservableDictionaryChangeType.ItemRemoved} and {ObservableDictionaryChangeType.Reset} are supported.</exception>
public static IList <IObservableCollectionChange <KeyValuePair <TKey, TValue> > > ToObservableCollectionChanges <TKey, TValue>(
this IObservableDictionaryChange <TKey, TValue> observableDictionaryChange,
IObservableDictionary <TKey, TValue> dictionary,
IEqualityComparer <TValue> valueComparer)
{
if (observableDictionaryChange == null)
{
throw new ArgumentNullException(nameof(observableDictionaryChange));
}
if (dictionary == null)
{
throw new ArgumentNullException(nameof(dictionary));
}
if (valueComparer == null)
{
throw new ArgumentNullException(nameof(valueComparer));
}
var result = new List <IObservableCollectionChange <KeyValuePair <TKey, TValue> > >();
switch (observableDictionaryChange.ChangeType)
{
case ObservableDictionaryChangeType.ItemAdded:
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemAdded,
new KeyValuePair <TKey, TValue>(observableDictionaryChange.Key, observableDictionaryChange.Value)));
break;
case ObservableDictionaryChangeType.ItemKeyChanged:
{
TValue valueForKey;
if (((IDictionary <TKey, TValue>)dictionary).TryGetValue(observableDictionaryChange.Key, out valueForKey))
{
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemChanged,
new KeyValuePair <TKey, TValue>(observableDictionaryChange.Key, valueForKey)));
}
break;
}
case ObservableDictionaryChangeType.ItemValueChanged:
{
result.AddRange(dictionary.GetKeysForValue(observableDictionaryChange.Value, valueComparer).Select(key =>
new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemChanged,
new KeyValuePair <TKey, TValue>(key, observableDictionaryChange.Value))));
}
break;
case ObservableDictionaryChangeType.ItemValueReplaced:
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemRemoved,
new KeyValuePair <TKey, TValue>(observableDictionaryChange.Key, observableDictionaryChange.OldValue)));
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemAdded,
new KeyValuePair <TKey, TValue>(observableDictionaryChange.Key, observableDictionaryChange.Value)));
break;
case ObservableDictionaryChangeType.ItemRemoved:
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.ItemRemoved,
new KeyValuePair <TKey, TValue>(observableDictionaryChange.Key, observableDictionaryChange.OldValue)));
break;
case ObservableDictionaryChangeType.Reset:
result.Add(new ObservableCollectionChange <KeyValuePair <TKey, TValue> >(
ObservableCollectionChangeType.Reset));
break;
default:
throw new ArgumentOutOfRangeException(nameof(observableDictionaryChange),
$"Only {ObservableDictionaryChangeType.ItemAdded}, {ObservableDictionaryChangeType.ItemValueChanged}, {ObservableDictionaryChangeType.ItemRemoved} and {ObservableDictionaryChangeType.Reset} are supported.");
}
return(result);
}
public void RemoveDictionaryNotifiers(IObservableDictionary <string, TestItem> obvDict)
{
obvDict.DictionaryChanged -= OnDictionaryChanged;
}
public static IReadOnlyObservableDictionary <TKey, TValue> ToReadOnly <TKey, TValue>
(this IObservableDictionary <TKey, TValue> self)
{
return((IReadOnlyObservableDictionary <TKey, TValue>)self);
}
/// <summary>
/// Returns all items in the observable dictionary after it has finished initialising, or immediately if already initialised.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static IObservable <IEnumerable <KeyValuePair <TKey, TValue> > > Items <TKey, TValue>(this IObservableDictionary <TKey, TValue> source)
{
return(from _ in source.IsInitialised()
from existingItems in source.TakeWhile(notification => notification.Type != DictionaryNotificationType.Initialised)
.Select(dn => new KeyValuePair <TKey, TValue>(dn.Key, dn.Value))
.ToList()
select existingItems.AsEnumerable());
}
/// <summary>
/// Gets a <see cref="IObservableDictionaryChange{TKey,TValue}" /> representing a <see cref="ObservableDictionaryChangeType.ItemValueReplaced" />,
/// more particularly one for an item replacement inside the <see cref="IObservableDictionary{TKey,TValue}" />.
/// </summary>
/// <param name="dictionary">The dictionary that this change is for and notifying about.</param>
/// <param name="key">The key.</param>
/// <param name="newValue">The new value.</param>
/// <param name="replacedOldValue">The replaced old value.</param>
/// <returns></returns>
/// <value>
/// An <see cref="IObservableDictionaryChange{TKey,TValue}">instance</see> representing an item replacement <see cref="ObservableDictionaryChangeType.ItemValueReplaced" />.
/// </value>
public static IObservableDictionaryChange <TKey, TValue> ItemValueReplaced(IObservableDictionary <TKey, TValue> dictionary, TKey key, TValue newValue, TValue replacedOldValue)
=> new ObservableDictionaryChange <TKey, TValue>(dictionary, ObservableDictionaryChangeType.ItemValueReplaced, key, newValue, replacedOldValue);
/// <summary>
/// Gets a <see cref="IObservableDictionaryChange{TKey,TValue}" /> representing a <see cref="ObservableDictionaryChangeType.ItemValueChanged" />,
/// meaning that a given <paramref name="value"/>, more precisely one of its properties, for one or more key(s) has changed.
/// </summary>
/// <param name="dictionary">The dictionary that this change is for and notifying about.</param>
/// <param name="value">The value.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns></returns>
/// <value>
/// An <see cref="IObservableDictionaryChange{TKey,TValue}">instance</see> representing an item property changed <see cref="ObservableDictionaryChangeType.ItemValueChanged" />.
/// </value>
public static IObservableDictionaryChange <TKey, TValue> ItemValueChanged(IObservableDictionary <TKey, TValue> dictionary, TValue value, string propertyName)
=> new ObservableDictionaryChange <TKey, TValue>(dictionary, ObservableDictionaryChangeType.ItemValueChanged, value: value, changedPropertyName: propertyName);
/// <summary>
/// Gets a <see cref="IObservableDictionaryChange{TKey,TValue}" /> representing a <see cref="ObservableDictionaryChangeType.ItemRemoved" />
/// for the given <paramref name="key" /> and <paramref name="value" />.
/// </summary>
/// <param name="dictionary">The dictionary that this change is for and notifying about.</param>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
/// <value>
/// An <see cref="IObservableDictionaryChange{TKey,TValue}">instance</see> representing a <see cref="ObservableDictionaryChangeType.ItemRemoved" />.
/// </value>
public static IObservableDictionaryChange <TKey, TValue> ItemRemoved(IObservableDictionary <TKey, TValue> dictionary, TKey key, TValue value)
=> new ObservableDictionaryChange <TKey, TValue>(dictionary, ObservableDictionaryChangeType.ItemRemoved, key, value);
/// <summary>
/// Gets a <see cref="IObservableDictionaryChange{TKey,TValue}" /> representing a <see cref="ObservableDictionaryChangeType.Reset" />.
/// </summary>
/// <param name="dictionary">The dictionary that this change is for and notifying about.</param>
/// <returns></returns>
/// <value>
/// An <see cref="IObservableDictionaryChange{TKey,TValue}">instance</see> representing a <see cref="ObservableDictionaryChangeType.Reset" />.
/// </value>
public static IObservableDictionaryChange <TKey, TValue> Reset(IObservableDictionary <TKey, TValue> dictionary)
=> new ObservableDictionaryChange <TKey, TValue>(dictionary, ObservableDictionaryChangeType.Reset);
