implement TableUpdate filter with IObservable predicate

This commit is contained in:
John Colvin committed 2019-03-09 22:09:27 -06:00
1 parent 82a93e39f8
commit af1fbaf3ed
1 file changed
+104
+104
View File
@@ -277,6 +277,53 @@ namespace bts.api.core {
internal Builder to_builder() =>
new Builder(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();
var added = new List<T>(raw_added.Where(predicate));
var removed = new List<T>(raw_removed.Where(predicate));
var 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;
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 TableUpdate<T, TKey>(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>();
foreach (var kv in unfiltered_state) {
if (old_predicate(kv.Value)) {
if (new_predicate(kv.Value)) {
continue;
} else {
removed.Add(kv.Value);
}
} else if (new_predicate(kv.Value)) {
added.Add(kv.Value);
}
}
var builder = filtered_target._state.ToBuilder();
var key = filtered_target.key_extractor;
builder.RemoveRange(removed.Select(key));
builder.AddRange(added.Select(v => new KeyValuePair<TKey, T>(key(v), v)));
return new TableUpdate<T, TKey>(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>
@@ -512,6 +559,63 @@ namespace bts.api.core {
public static IObservable<TableUpdate<T, TKey>> Filter<T, TKey>(this IObservable<TableUpdate<T, TKey>> source, Func<T, bool> predicate, Func<T, TKey> key) where TKey : IEquatable<TKey> =>
source.Scan(TableUpdate<T, TKey>.mk_empty(key), (src, tgt) => _apply_predicate(src, tgt, predicate, key));
public static IObservable<TableUpdate<T, TKey>> Filter<T, TKey>(this IObservable<TableUpdate<T, TKey>> table_source, IObservable<Func<T, bool>> predicate_source, Func<T, TKey> key) where TKey : IEquatable<TKey> =>
Observable.Create<TableUpdate<T, TKey>>(observer => {
TableUpdate<T, TKey> unfiltered_table = TableUpdate<T, TKey>.mk_empty(key), filtered_table = TableUpdate<T, TKey>.mk_empty(key);
Func<T, bool> predicate = _ => true;
Log.DataFlow.diag($"Create Table Filter {typeof(T).Name}");
bool is_busy = false;
var op_queue = new Queue<(TableUpdate<T, TKey> pending_table, Func<T, bool> pending_predicate)>();
return new CompositeDisposable(table_source.Subscribe(on_table), predicate_source.Subscribe(on_predicate));
void on_predicate(Func<T, bool> new_predicate) {
if (try_begin_op((null, new_predicate)))
process_predicate(new_predicate);
}
void process_predicate(Func<T, bool> new_predicate) {
filtered_table = TableUpdate<T, TKey>.FilterHelper.on_predicate_changed(filtered_table, unfiltered_table.state, predicate, new_predicate);
predicate = new_predicate;
on_op_completed();
}
void on_table(TableUpdate<T, TKey> new_table) {
if (try_begin_op((new_table, null)))
process_table(new_table);
}
void process_table(TableUpdate<T, TKey> new_table) {
unfiltered_table = new_table;
filtered_table = TableUpdate<T, TKey>.FilterHelper.on_source_changed(filtered_table, new_table.added, new_table.changes, new_table.removed, predicate);
on_op_completed();
}
bool try_begin_op((TableUpdate<T, TKey> table, Func<T, bool> predicate) op) {
lock (op_queue) {
if (is_busy) {
op_queue.Enqueue(op);
return false;
} else {
is_busy = true;
return true;
}
}
}
void on_op_completed() {
observer.OnNext(filtered_table);
Log.assert(is_busy);
(TableUpdate<T, TKey> table, Func<T, bool> predicate) buffered_op;
lock (op_queue) {
if (op_queue.Count == 0) {
is_busy = false;
return;
}
buffered_op = op_queue.Dequeue();
}
if (buffered_op.table != null) {
process_table(buffered_op.table);
} else {
process_predicate(buffered_op.predicate);
}
}
});
static TableUpdate<T, TKey> _apply_predicate<T, TKey>(TableUpdate<T, TKey> tgt_table, TableUpdate<T, TKey> src_table, Func<T, bool> predicate, Func<T, TKey> key) where TKey : IEquatable<TKey> {
var added = src_table.added.Where(predicate).ToList();
var removed = src_table.removed.Where(predicate).ToList();