diff --git a/src/client/spark_core/utils/MappedDictionary.cs b/src/client/spark_core/utils/MappedDictionary.cs index 0863b7df5..6bd7a9f65 100644 --- a/src/client/spark_core/utils/MappedDictionary.cs +++ b/src/client/spark_core/utils/MappedDictionary.cs @@ -1,4 +1,5 @@ -using System; +using bts.utils; +using System; using System.Collections; using System.Collections.Generic; using System.Linq; @@ -11,6 +12,19 @@ namespace bts.collections { public static IReadOnlyDictionary create(IReadOnlyDictionary source, Func, TResult> map) => new KeyValueWrapper(source, map); + public static IReadOnlyDictionary create(IReadOnlyDictionary source, Func convert, Func convert_key, Func convert_key_back) => + new KeyValueWrapper(source, convert, convert_key, convert_key_back); + + public static IDictionary create_mutable( + IDictionary source, + Func convert_key, + Func convert_key_back, + Func convert_value, + Func convert_value_back) => + // + new MutableKeyValueWrapper(source, convert_key, convert_key_back, convert_value, convert_value_back); + + class KeyValueWrapper : IReadOnlyDictionary { readonly IReadOnlyDictionary _source; readonly Func, TResult> _map; @@ -47,6 +61,120 @@ namespace bts.collections { } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } + + class KeyValueWrapper : IReadOnlyDictionary { + readonly IReadOnlyDictionary _source; + readonly Func _convert; + readonly Func _convert_key; + readonly Func _convert_key_back; + + public KeyValueWrapper(IReadOnlyDictionary source, Func convert, Func convert_key, Func convert_key_back) { + _source = source; + _convert = convert; + _convert_key = convert_key; + _convert_key_back = convert_key_back; + } + + public TResult this[TResultKey key] => _convert(_source[_convert_key_back(key)]); + public IEnumerable Keys => _source.Keys.Select(_convert_key); + + public IEnumerable Values { + get { + foreach (var v in _source.Values) + yield return _convert(v); + } + } + + public int Count => _source.Count; + + public bool ContainsKey(TResultKey key) => _source.ContainsKey(_convert_key_back(key)); + public IEnumerator> GetEnumerator() { + foreach (var kv in _source) + yield return new KeyValuePair(_convert_key(kv.Key), _convert(kv.Value)); + } + public bool TryGetValue(TResultKey key, out TResult value) { + if (_source.TryGetValue(_convert_key_back(key), out var v)) { + value = _convert(v); + return true; + } + value = default; + return false; + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + + class MutableKeyValueWrapper : IDictionary { + readonly IDictionary _source; + readonly Func _convert_key; + readonly Func _convert_key_back; + readonly Func _convert_value; + readonly Func _convert_value_back; + ICollection _keys; + ICollection _values; + + public MutableKeyValueWrapper( + IDictionary source, + Func convert_key, + Func convert_key_back, + Func convert_value, + Func convert_value_back) { + // + _source = source ?? throw new ArgumentNullException(nameof(source)); + _convert_key = convert_key ?? throw new ArgumentNullException(nameof(convert_key)); + _convert_key_back = convert_key_back ?? throw new ArgumentException(nameof(convert_key_back)); + _convert_value = convert_value ?? throw new ArgumentNullException(nameof(convert_value)); + _convert_value_back = convert_value_back ?? throw new ArgumentNullException(nameof(convert_value_back)); + } + + // Indexer + public TResult this[TResultKey key] { + get => _convert_value(_source[_convert_key_back(key)]); + set => _source[_convert_key_back(key)] = _convert_value_back(value); + } + // Keys/Values + public ICollection Keys => _keys ?? (_keys = CollectionHelper.wrap_selector(_source.Keys, _convert_key, null)); + public ICollection Values => _values ?? (_values = CollectionHelper.wrap_selector(_source.Values, _convert_value, null)); + // Count/IsReadOnly + public int Count => _source.Count; + public bool IsReadOnly => _source.IsReadOnly; + + // IDictionary Methods + public void Add(TResultKey key, TResult value) => + _source.Add(_convert_key_back(key), _convert_value_back(value)); + + public void Add(KeyValuePair item) => + _source.Add(_convert_key_back(item.Key), _convert_value_back(item.Value)); + + public void Clear() => + _source.Clear(); + + public bool Contains(KeyValuePair item) => + _source.TryGetValue(_convert_key_back(item.Key), out var v) && Equals(item.Value, _convert_value(v)); + + public bool ContainsKey(TResultKey key) => _source.ContainsKey(_convert_key_back(key)); + public void CopyTo(KeyValuePair[] array, int arrayIndex) { + foreach (var kv in _source) + array[arrayIndex++] = new KeyValuePair(_convert_key(kv.Key), _convert_value(kv.Value)); + } + public IEnumerator> GetEnumerator() { + foreach (var kv in _source) + yield return new KeyValuePair(_convert_key(kv.Key), _convert_value(kv.Value)); + } + public bool Remove(TResultKey key) => _source.Remove(_convert_key_back(key)); + public bool Remove(KeyValuePair item) => + _source.TryPopValueIf(_convert_key_back(item.Key), v => Equals(v, _convert_value_back(item.Value))); + + public bool TryGetValue(TResultKey key, out TResult value) { + if (_source.TryGetValue(_convert_key_back(key), out var v)) { + value = _convert_value(v); + return true; + } + value = default; + return false; + } + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } } internal class MappedDictionary : IReadOnlyDictionary {