So we can create ViewStreams that depend on other services, config, etc. Previously, the PrimitiveManager relied purely on static construction of types through reflection.
333 lines
12 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|