#nullable enable namespace bts.api.core { using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics.CodeAnalysis; using System.Linq; public class TableUpdate where TKey : IEquatable { // warning: this does not have a key_extractor public static readonly TableUpdate empty = new( ImmutableDictionary.Empty, Array.Empty(), Array.Empty>(), Array.Empty(), null); readonly ImmutableDictionary _state; public TableUpdate( ImmutableDictionary init, IEnumerable added, IEnumerable> changes, IEnumerable removed, Func? key_extractor) { _state = init; this.added = added; this.changes = changes; this.removed = removed; this.key_extractor = key_extractor; } public IReadOnlyDictionary state => _state; public IEnumerable added { get; } public IEnumerable> changes { get; } public IEnumerable changed => changes.Select(c => c.New); public IEnumerable removed { get; } public Func? key_extractor { get; private set; } public static TableUpdate mk_empty(Func key_extractor) => new( ImmutableDictionary.Empty, Array.Empty(), Array.Empty>(), Array.Empty(), key_extractor); internal static TableUpdate update( TableUpdate table, Update upd) => update(table, upd.added, upd.changes, upd.removed, upd.key); internal static TableUpdate update( TableUpdate table, TableUpdate upd) => update(table, upd.added, upd.changes, upd.removed, upd.key_extractor); internal static TableUpdate update( TableUpdate table, IEnumerable added, IEnumerable> changes, IEnumerable removed, Func? key = null ) { key ??= table.key_extractor ?? throw new ArgumentNullException( nameof(key), $"{nameof(table)}.{nameof(table.key_extractor)} is also null"); var builder = table._state.ToBuilder(); builder.RemoveRange(removed.Select(i => key(i))); builder.AddRange(added.Select(i => new KeyValuePair(key(i), i))); foreach (var i in changes) { builder[key(i.New)] = i.New; } return new(builder.ToImmutable(), added, changes, removed, key); } internal static TableUpdate update( TableUpdate table, IReadOnlyDictionary new_state, IEqualityComparer value_comparer ) { var builder = table._state.ToBuilder(); // removed/changes var removed = new List(); var changes = new List>(); foreach (var kv in table._state) { if (new_state.TryGetValue(kv.Key, out var new_val)) { if (!value_comparer.Equals(kv.Value, new_val)) { changes.Add(new(kv.Value, new_val)); builder[kv.Key] = new_val; } continue; } removed.Add(kv.Value); builder.Remove(kv.Key); } // added var added = new List(); foreach (var kv in new_state) { if (!table._state.ContainsKey(kv.Key)) { added.Add(kv.Value); builder.Add(kv); } } return new(builder.ToImmutable(), added, changes, removed, table.key_extractor); } internal TableUpdate as_snapshot() => new( _state, _state.Values.ToList(), Enumerable.Empty>(), Enumerable.Empty(), key_extractor); public TableUpdate clear_changes() => new( _state, Enumerable.Empty(), Enumerable.Empty>(), Enumerable.Empty(), key_extractor); public Builder to_builder() => new(this); public static class FilterHelper { internal static TableUpdate on_source_changed( TableUpdate filtered_target, IEnumerable raw_added, IEnumerable> raw_changes, IEnumerable raw_removed, Func predicate ) { var builder = filtered_target._state.ToBuilder(); List added; List removed; List> changes; if (predicate == null) { added = raw_added.ToList(); removed = raw_removed.ToList(); changes = raw_changes.ToList(); } else { added = raw_added.Where(predicate).ToList(); removed = raw_removed.Where(predicate).ToList(); changes = new List>(); foreach (var ch in raw_changes) { if (predicate(ch.Old)) { if (predicate(ch.New)) { changes.Add(ch); } else { removed.Add(ch.Old); } } else if (predicate(ch.New)) { added.Add(ch.New); } } } var key = filtered_target.key_extractor; if (removed.Count > 0 || changes.Count > 0 || added.Count > 0) { if (key is null) { throw new InvalidOperationException(); } builder.RemoveRange(removed.Select(key)); foreach (var ch in changes) { builder[key(ch.New)] = ch.New; } builder.AddRange(added.Select(v => new KeyValuePair(key(v), v))); } return new(builder.ToImmutable(), added, changes, removed, key); } internal static TableUpdate on_predicate_changed( TableUpdate filtered_target, IReadOnlyDictionary unfiltered_state, Func old_predicate, Func new_predicate ) { var added = new List(); var removed = new List(); if (new_predicate == old_predicate) { // Nothing changed - this method probably shouldn't be called when nothing changes. // Having said that, it doesn't really hurt anything, so don't throw a metaphorical // wrench into the gears by throwing a literal exception. Return the table as is. if (filtered_target.has_changes()) { filtered_target = new( filtered_target._state, Enumerable.Empty(), Enumerable.Empty>(), Enumerable.Empty(), filtered_target.key_extractor); } return filtered_target; } if (old_predicate is null) { removed.AddRange(filtered_target.state.Values.Where(v => !new_predicate(v))); } else if (new_predicate is null) { added.AddRange(unfiltered_state.Values.Where(v => !old_predicate(v))); } else { foreach (var kv in unfiltered_state) { if (old_predicate(kv.Value)) { if (new_predicate(kv.Value)) { // no-op: was included before, and is included now continue; } else { // remove: was included before, and isn't included now removed.Add(kv.Value); } } else if (new_predicate(kv.Value)) { // add: wasn't included before, and is included now added.Add(kv.Value); } } } var builder = filtered_target._state.ToBuilder(); var key = filtered_target.key_extractor; if (removed.Count > 0 || added.Count > 0) { if (key is null) { throw new InvalidOperationException(); } builder.RemoveRange(removed.Select(key)); builder.AddRange(added.Select(v => new KeyValuePair(key(v), v))); } return new( builder.ToImmutable(), added, Array.Empty>(), removed, key); } } /// /// This class is used to aggregate a series of changes into a single update. /// public class Builder { readonly TableUpdate _state; readonly Dictionary _added = new(); readonly Dictionary _removed = new(); readonly Dictionary> _changes = new(); public Builder(TableUpdate state) => _state = state; Func _key => _state.key_extractor ?? throw new InvalidOperationException("TableUpdate.key_extractor is null"); public void add_or_update(T value) => add_or_update(_key(value), value); public void add_or_update(TKey key, T value) { if (_state.state.TryGetValue(key, out var curr)) { _removed.Remove(key); _changes[key] = new Change(curr, value); } else { _added[key] = value; } } public void remove(TKey key) { if (_state.state.TryGetValue(key, out var orig)) { _removed[key] = orig; _changes.Remove(key); } else { _added.Remove(key); } } public void remove(T value) => remove(_key(value)); public void merge_table(TableUpdate table, Func _key) { foreach (T v in table.removed) remove(_key(v)); foreach (T v in table.added.Concat(table.changed)) add_or_update(_key(v), v); } public void clear() { _added.Clear(); _changes.Clear(); foreach (var kv in _state.state) _removed[kv.Key] = kv.Value; } public bool TryGetValue(TKey key, [MaybeNullWhen(false)]out T result) { if(_added.TryGetValue(key, out result)) { return true; } if (_changes.TryGetValue(key, out var ch)) { result = ch.New; return true; } return !_removed.ContainsKey(key) && _state.state.TryGetValue(key, out result); } /// /// Creates a TableUpdate instance from the current state /// public TableUpdate to_table() { var builder = _state._state.ToBuilder(); builder.RemoveRange(_removed.Keys); foreach (var kv in _changes) { builder[kv.Key] = kv.Value.New; } builder.AddRange(_added); var new_state = builder.ToImmutable(); return new( new_state, _added.Values, _changes.Values, _removed.Values, _state.key_extractor); } /// /// Creates a TableUpdate instance from the current state (uses /// to filter out 'changes' whose value didn't actually change) /// public TableUpdate to_table_checked(IEqualityComparer comparer) { var builder = _state._state.ToBuilder(); builder.RemoveRange(_removed.Keys); var false_change_keys = new List(0); foreach (var kv in _changes) { if (comparer.Equals(kv.Value.Old, kv.Value.New)) { false_change_keys.Add(kv.Key); continue; } builder[kv.Key] = kv.Value.New; } foreach (var k in false_change_keys) { _changes.Remove(k); } builder.AddRange(_added); var new_state = builder.ToImmutable(); return new( new_state, _added.Values, _changes.Values, _removed.Values, _state.key_extractor); } } } }