Files
spark/src/client/spark_core/Reactive/RootDependentSubscription.cs
T

145 lines
5.0 KiB
C#

#nullable enable
namespace Spark.Core.Reactive {
using bts.api.core;
using bts.collections;
using Spark.Core.Disposables;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
class RootDependentSubscription<T, TKey, TResult> : IDisposable where TKey : IEquatable<TKey> {
readonly IObserver<TableUpdate<TResult, TKey>> _observer;
readonly Func<T, TKey> _key;
readonly Func<T, TKey> _parent_key;
readonly Func<T, T, TResult> _get_result;
readonly Func<T, TResult> _get_result_no_parent;
readonly Func<TResult, TKey> _result_key;
readonly TKey _no_parent_key;
readonly SetMap<TKey, T> _parent_to_children = new();
IReadOnlyDictionary<TKey, T> _state = ImmutableDictionary<TKey, T>.Empty;
TableUpdate<TResult, TKey> _output;
IDisposable? _dispose;
public RootDependentSubscription(
IObservable<TableUpdate<T, TKey>> source,
IObserver<TableUpdate<TResult, TKey>> observer,
Func<T, TKey> key,
Func<T, TKey> parent_key,
Func<T, T, TResult> get_result,
Func<T, TResult> get_result_no_parent,
Func<TResult, TKey> result_key,
TKey no_parent_key) {
_observer = observer;
_key = key;
_parent_key = parent_key;
_get_result = get_result;
_get_result_no_parent = get_result_no_parent;
_result_key = result_key;
_no_parent_key = no_parent_key;
_output = TableUpdate<TResult, TKey>.mk_empty(_result_key);
_dispose = source.Subscribe(_on_next);
}
public void Dispose() =>
Disposable.dispose_thread_safe(ref _dispose);
void _on_next(TableUpdate<T, TKey> input) {
_state = input.state;
var builder = _output.to_builder();
// Execute parent_to_children changes first, so descendent-propagation will be
// efficient (otherwise propagation might be needlessly performed on values that are yet
// to be removed, or performed with the wrong root, if the real root is yet to be added).
foreach (var v in input.removed.Concat(input.changes.Select(ch => ch.Old))) {
_parent_to_children.remove(_parent_key(v), v);
}
foreach (var v in input.added.Concat(input.changed)) {
var pk = _parent_key(v);
if (!pk.Equals(_no_parent_key)) {
_parent_to_children.add(pk, v);
}
}
// removed
foreach (var v in input.removed) {
var k = _key(v);
builder.remove(k);
if (_parent_to_children.try_lookup(k, out var children)) {
foreach (var child in children) {
var ck = _key(child);
builder.add_or_update(ck, _get_result_no_parent(child));
foreach (var d in _descendents(ck)) {
builder.add_or_update(_key(d), _get_result(d, child));
}
}
}
}
// changed
foreach (var v in input.changed) {
var k = _key(v);
var root = _get_root(v);
TResult result;
if (_key(root).Equals(k)) {
result = _get_result_no_parent(v);
foreach (var d in _descendents(k)) {
builder.add_or_update(_key(d), _get_result(d, v));
}
} else {
result = _get_result(v, root);
}
builder.add_or_update(k, result);
}
// added
foreach (var v in input.added) {
var k = _key(v);
var pk = _parent_key(v);
TResult result;
if (pk.Equals(_no_parent_key)) {
result = _get_result_no_parent(v);
foreach (var d in _descendents(k)) {
builder.add_or_update(_key(d), _get_result(d, v));
}
} else {
_parent_to_children.add(pk, v);
var root = _get_root(v);
if (_key(root).Equals(k)) {
result = _get_result_no_parent(v);
foreach (var d in _descendents(k))
builder.add_or_update(_key(d), _get_result(d, v));
} else {
result = _get_result(v, root);
}
}
builder.add_or_update(k, result);
}
_observer.OnNext(_output = builder.to_table());
}
T _get_root(T value) {
var pk = _parent_key(value);
while (!pk.Equals(_no_parent_key) && _state.TryGetValue(pk, out var parent)) {
value = parent;
pk = _parent_key(value);
}
return value;
}
IEnumerable<T> _descendents(TKey k) {
if (!_parent_to_children.try_lookup(k, out var children)) {
yield break;
}
foreach (var child in children) {
yield return child;
foreach (var d in _descendents(_key(child))) {
yield return d;
}
}
}
}
}