From af1fbaf3ed1986fc9a5f91bbfa8340b6cc238d38 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Sat, 9 Mar 2019 21:39:03 -0600 Subject: [PATCH] implement TableUpdate filter with IObservable predicate --- src/client/spark_api/api/Update.cs | 104 +++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/src/client/spark_api/api/Update.cs b/src/client/spark_api/api/Update.cs index 1c751e774..4866d1b8a 100644 --- a/src/client/spark_api/api/Update.cs +++ b/src/client/spark_api/api/Update.cs @@ -277,6 +277,53 @@ namespace bts.api.core { internal Builder to_builder() => new Builder(this); + public static class FilterHelper { + internal static TableUpdate on_source_changed(TableUpdate filtered_target, IEnumerable raw_added, IEnumerable> raw_changes, IEnumerable raw_removed, Func predicate) { + var builder = filtered_target._state.ToBuilder(); + var added = new List(raw_added.Where(predicate)); + var removed = new List(raw_removed.Where(predicate)); + var changes = new List>(); + 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(key(v), v))); + return new TableUpdate(builder.ToImmutable(), added, changes, removed, key); + } + + internal static TableUpdate on_predicate_changed(TableUpdate filtered_target, IReadOnlyDictionary unfiltered_state, Func old_predicate, Func new_predicate) { + var added = new List(); + var removed = new List(); + 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(key(v), v))); + return new TableUpdate(builder.ToImmutable(), added, Array.Empty>(), removed, key); + } + } + /// /// This class is used to aggregate a series of changes into a single update. /// @@ -512,6 +559,63 @@ namespace bts.api.core { public static IObservable> Filter(this IObservable> source, Func predicate, Func key) where TKey : IEquatable => source.Scan(TableUpdate.mk_empty(key), (src, tgt) => _apply_predicate(src, tgt, predicate, key)); + public static IObservable> Filter(this IObservable> table_source, IObservable> predicate_source, Func key) where TKey : IEquatable => + Observable.Create>(observer => { + TableUpdate unfiltered_table = TableUpdate.mk_empty(key), filtered_table = TableUpdate.mk_empty(key); + Func predicate = _ => true; + Log.DataFlow.diag($"Create Table Filter {typeof(T).Name}"); + bool is_busy = false; + var op_queue = new Queue<(TableUpdate pending_table, Func pending_predicate)>(); + return new CompositeDisposable(table_source.Subscribe(on_table), predicate_source.Subscribe(on_predicate)); + + void on_predicate(Func new_predicate) { + if (try_begin_op((null, new_predicate))) + process_predicate(new_predicate); + } + void process_predicate(Func new_predicate) { + filtered_table = TableUpdate.FilterHelper.on_predicate_changed(filtered_table, unfiltered_table.state, predicate, new_predicate); + predicate = new_predicate; + on_op_completed(); + } + void on_table(TableUpdate new_table) { + if (try_begin_op((new_table, null))) + process_table(new_table); + } + void process_table(TableUpdate new_table) { + unfiltered_table = new_table; + filtered_table = TableUpdate.FilterHelper.on_source_changed(filtered_table, new_table.added, new_table.changes, new_table.removed, predicate); + on_op_completed(); + } + bool try_begin_op((TableUpdate table, Func 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 table, Func 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 _apply_predicate(TableUpdate tgt_table, TableUpdate src_table, Func predicate, Func key) where TKey : IEquatable { var added = src_table.added.Where(predicate).ToList(); var removed = src_table.removed.Where(predicate).ToList();