Files
spark/src/client/spark_core/Update/TableUpdate.cs
T
John Colvin ea0a1fbcd3 refactor: Load IDataStreamFactory(s) with dependency injection
So we can create ViewStreams that depend on other services, config, etc.
Previously, the PrimitiveManager relied purely on static construction of
types through reflection.
2025-11-19 13:53:18 -05:00

333 lines
12 KiB
C#

#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<T, TKey> where TKey : IEquatable<TKey> {
// warning: this does not have a key_extractor
public static readonly TableUpdate<T, TKey> empty = new(
ImmutableDictionary<TKey, T>.Empty,
Array.Empty<T>(),
Array.Empty<Change<T>>(),
Array.Empty<T>(),
null);
readonly ImmutableDictionary<TKey, T> _state;
public TableUpdate(
ImmutableDictionary<TKey, T> init,
IEnumerable<T> added,
IEnumerable<Change<T>> changes,
IEnumerable<T> removed,
Func<T, TKey>? key_extractor) {
_state = init;
this.added = added;
this.changes = changes;
this.removed = removed;
this.key_extractor = key_extractor;
}
public IReadOnlyDictionary<TKey, T> state => _state;
public IEnumerable<T> added { get; }
public IEnumerable<Change<T>> changes { get; }
public IEnumerable<T> changed => changes.Select(c => c.New);
public IEnumerable<T> removed { get; }
public Func<T, TKey>? key_extractor { get; private set; }
public static TableUpdate<T, TKey> mk_empty(Func<T, TKey> key_extractor) => new(
ImmutableDictionary<TKey, T>.Empty,
Array.Empty<T>(),
Array.Empty<Change<T>>(),
Array.Empty<T>(),
key_extractor);
internal static TableUpdate<T, TKey> update(
TableUpdate<T, TKey> table, Update<T, TKey> upd) =>
update(table, upd.added, upd.changes, upd.removed, upd.key);
internal static TableUpdate<T, TKey> update(
TableUpdate<T, TKey> table, TableUpdate<T, TKey> upd) =>
update(table, upd.added, upd.changes, upd.removed, upd.key_extractor);
internal static TableUpdate<T, TKey> update(
TableUpdate<T, TKey> table,
IEnumerable<T> added,
IEnumerable<Change<T>> changes,
IEnumerable<T> removed,
Func<T, TKey>? 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<TKey, T>(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<T, TKey> update(
TableUpdate<T, TKey> table,
IReadOnlyDictionary<TKey, T> new_state,
IEqualityComparer<T> value_comparer
) {
var builder = table._state.ToBuilder();
// removed/changes
var removed = new List<T>();
var changes = new List<Change<T>>();
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<T>();
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<T, TKey> as_snapshot() => new(
_state,
_state.Values.ToList(),
Enumerable.Empty<Change<T>>(),
Enumerable.Empty<T>(),
key_extractor);
public TableUpdate<T, TKey> clear_changes() => new(
_state,
Enumerable.Empty<T>(),
Enumerable.Empty<Change<T>>(),
Enumerable.Empty<T>(),
key_extractor);
public Builder to_builder() =>
new(this);
public static class FilterHelper {
internal static TableUpdate<T, TKey> on_source_changed(
TableUpdate<T, TKey> filtered_target,
IEnumerable<T> raw_added,
IEnumerable<Change<T>> raw_changes,
IEnumerable<T> raw_removed,
Func<T, bool> predicate
) {
var builder = filtered_target._state.ToBuilder();
List<T> added;
List<T> removed;
List<Change<T>> 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<Change<T>>();
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<TKey, T>(key(v), v)));
}
return new(builder.ToImmutable(), added, changes, removed, key);
}
internal static TableUpdate<T, TKey> on_predicate_changed(
TableUpdate<T, TKey> filtered_target,
IReadOnlyDictionary<TKey, T> unfiltered_state,
Func<T, bool> old_predicate,
Func<T, bool> new_predicate
) {
var added = new List<T>();
var removed = new List<T>();
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<T>(),
Enumerable.Empty<Change<T>>(),
Enumerable.Empty<T>(),
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<TKey, T>(key(v), v)));
}
return new(
builder.ToImmutable(), added, Array.Empty<Change<T>>(), removed, key);
}
}
/// <summary>
/// This class is used to aggregate a series of changes into a single update.
/// </summary>
public class Builder {
readonly TableUpdate<T, TKey> _state;
readonly Dictionary<TKey, T> _added = new();
readonly Dictionary<TKey, T> _removed = new();
readonly Dictionary<TKey, Change<T>> _changes = new();
public Builder(TableUpdate<T, TKey> state) =>
_state = state;
Func<T, TKey> _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<T>(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<T, TKey> table, Func<T, TKey> _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);
}
/// <summary>
/// Creates a TableUpdate instance from the current state
/// </summary>
public TableUpdate<T, TKey> 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);
}
/// <summary>
/// Creates a TableUpdate instance from the current state (uses
/// <paramref name="comparer"/> to filter out 'changes' whose value didn't actually change)
/// </summary>
public TableUpdate<T, TKey> to_table_checked(IEqualityComparer<T> comparer) {
var builder = _state._state.ToBuilder();
builder.RemoveRange(_removed.Keys);
var false_change_keys = new List<TKey>(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);
}
}
}
}