145 lines
5.0 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|