diff --git a/src/client/spark/Modules/Market/MarketView/MarketViewVM.cs b/src/client/spark/Modules/Market/MarketView/MarketViewVM.cs index b0bb2fce0..e6b60120b 100644 --- a/src/client/spark/Modules/Market/MarketView/MarketViewVM.cs +++ b/src/client/spark/Modules/Market/MarketView/MarketViewVM.cs @@ -5,13 +5,13 @@ using mbts.ui.utility; using System; using System.Collections.Generic; using System.Collections.ObjectModel; +using System.Reactive.Linq; +using System.Reactive.Subjects; using System.Windows.Data; using System.Windows.Media; -using System.Reactive.Linq; using static bts.shell.MarketViewWindowFactory; using static mbts.ui.controls.DIYGrid; using static mbts.ui.spark.MarketViewView; -using mbts.utils; namespace mbts.spark { partial class MarketViewVM : SecurityMDGrid { @@ -19,10 +19,11 @@ namespace mbts.spark { readonly OrdersModel _orders_model; public MarketViewVM(IBus bus, OrdersModel orders_model, IObservable state) - : this(bus, orders_model, state, new KeyDrivenObservable>(s => s.subscribe_md(bus))) { } + : this(bus, orders_model, state, state.SelectManyInSeries(s => s.security_criteria.subscribe_md(bus))) { } - MarketViewVM(IBus bus, OrdersModel orders_model, IObservable state, KeyDrivenObservable> securities_source) - : base(RXCollection.Create(securities_source, SecurityDataHelper.EqualityComparer.MDComparer), null) { + // securities_connectable should NOT be connected already. + MarketViewVM(IBus bus, OrdersModel orders_model, IObservable state, IConnectableObservable> securities_connectable) + : base(RXCollection.Create(securities_connectable, SecurityDataHelper.EqualityComparer.MDComparer), null) { _bus = bus; _orders_model = orders_model; security_filter = new RegexFilterVM(r => r.security.ToString(), nameof(Row.security)); @@ -111,8 +112,7 @@ namespace mbts.spark { }), DataGridFilterHelper.hook_filters(rows_view, security_filter, bid_price_filter, bid_size_filter, ask_price_filter, ask_size_filter, last_price_filter, last_size_filter, day_change_filter, settlement_filter, session_low_filter, session_high_filter, position_filter, working_bid_volume_filter, working_ask_volume_filter, volume_filter, security_key_filter), - state.Select(s => s.security_criteria).Subscribe(securities_source), - securities_source, + securities_connectable.Connect(), WorkLoop.Start("MarketView", _refresh) ); } diff --git a/src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs b/src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs index 15eb463dc..639c127c7 100644 --- a/src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs +++ b/src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs @@ -57,9 +57,10 @@ namespace mbts.spark { public void thread_init() { _dispose_resources(); _vm = new SingleValuePump(); + var connectable_builder = new ConnectableSeriesBuilder(_vm.observable); var update_securities_cmd = SparkCommands.change_securities_callback(_window_type_display_name); - var current_smd_source = _vm.observable.SelectMany(vm => vm.current_security_md_observable(_bus)).OnDispatcher(); - var selected_secs_source = _vm.observable.SelectMany(vm => vm.selected_securities_observable()).OnDispatcher(); + var current_smd_source = connectable_builder.create(vm => vm.current_security_md_observable(_bus)).OnDispatcher(); + var selected_secs_source = connectable_builder.create(vm => vm.selected_securities_observable()).OnDispatcher(); _commands = new SparkCommand[] { SparkCommands.ShowLadder.complete(current_smd_source, md => md.HasValue, ObjectHelper.ValueOrDefault), SparkCommands.ShowOrderTicketFromSecurity.complete(current_smd_source, md => md.HasValue, ObjectHelper.ValueOrDefault), @@ -67,7 +68,9 @@ namespace mbts.spark { SparkCommands.ShowMarketView.complete(selected_secs_source, always_true, secs => secs.Count > 0 ? new SecurityCriteria(secs) : _state.security_criteria), SparkCommands.change_securities_command(() => (update_securities_cmd, _state.security_criteria)) }; - _subscriptions = _bus.subscribe(update_securities_cmd.tag).OnDispatcher().Subscribe(update_criteria); + _subscriptions = Disposable.Create( + _bus.subscribe(update_securities_cmd.tag).OnDispatcher().Subscribe(update_criteria), + connectable_builder.connect_all()); _initialize(); bool always_true(T _) => true; diff --git a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs index cecaa8d50..8bccc80d9 100644 --- a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs +++ b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs @@ -19,6 +19,7 @@ namespace mbts.spark { StartupData _state; OrdersModel _orders_model; SyntheticManagementView _view; + IDisposable _subscriptions; public static SyntheticManagementWindow create(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model, StartupData state) { var window = new SyntheticManagementWindow(factory, bus, orders_model); @@ -29,20 +30,23 @@ namespace mbts.spark { SyntheticManagementWindow(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model) : base("Synthetic Management", bus, factory, SparkCommands.ShowSyntheticManagement.icon) { _orders_model = orders_model; + var vm_connectable_builder = new ConnectableSeriesBuilder(_vm.observable); + var current_row_source = vm_connectable_builder.create(vm => vm.current_row_observable); + var current_row_connectable_builder = new ConnectableSeriesBuilder(current_row_source); Commands = new SparkCommand[] { SparkCommand.create("Add", Icons.AddSynthetic, SparkTags.ShowSyntheticCreateTag).complete( () => new SecurityCriteria(), () => true ), SparkCommand.create("Remove", Icons.RemoveSynthetic, SparkTags.SyntheticDeleteTag).complete( - _vm.observable.SelectMany(vm => vm.current_row_observable.SelectMany(observe_row_mod_params)), + current_row_connectable_builder.create(observe_row_mod_params), can_execute, select_security_id ), SparkCommand.create("Change", Icons.ModifySynthetic, SparkTags.ShowSyntheticStrategyTag).complete( - _vm.observable.SelectMany(vm => vm.current_row_observable), + current_row_source, r => r != null, r => r?.security ?? SecurityDataHelper.Defaults.SecurityImmutable ), SparkCommand.create("Clone", Icons.CloneSynthetic, SparkTags.ShowSyntheticCloneTag).complete( - _vm.observable.SelectMany(vm => vm.current_row_observable.SelectMany(observe_row_strategy)), + current_row_connectable_builder.create(observe_row_strategy), rs => rs.HasValue, select_row_strategy_tuple ), SparkCommands.ShowLadder.complete( - _vm.observable.SelectMany(vm => vm.current_security_md), md => md.HasValue, ObjectHelper.ValueOrDefault + vm_connectable_builder.create(vm => vm.current_security_md), md => md.HasValue, ObjectHelper.ValueOrDefault ), SparkCommands.ShowOrders.complete(() => new OrderBookWindowFactory.OrderBookStartupData { filters = new OrderBookWindowFactory.FilterStates { security_criteria = new SecurityCriteria(_vm.value.row_vms.Select(r => r.security)) @@ -50,6 +54,10 @@ namespace mbts.spark { }) }; + _subscriptions = Disposable.Create( + vm_connectable_builder.connect_all(), + current_row_connectable_builder.connect_all()); + IObservable observe_row_mod_params(SyntheticManagementDialogVM.Row r) => r == null ? Observable.Return(new RowModificationParams?()) : _orders_model.security_has_working_orders(r.security_key).Select(hwo => RowModificationParams.create(r.security, hwo)); diff --git a/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs b/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs index 4a004b556..944ce0305 100644 --- a/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs @@ -334,6 +334,20 @@ namespace System.Reactive.Linq public static IObservable<(TSource prev, TSource curr)> PairWithPrevious(this IObservable source, TSource default_value) => source.Scan((default_value, default_value), (last, next) => (last.curr, next)); + /// + /// Uses each element of a source observable to create an inner observable of , unlike , + /// each inner sequence is terminated when the next one begins. + /// In other words, observers are notified by the inner observerables in "series," rather than "parallel." + /// + /// + /// + /// + /// + /// + /// + public static IConnectableObservable SelectManyInSeries(this IObservable source, Func> select_next) => + new ConnectableSeriesSource(source).create_connectable(select_next); + public static async Task<(T result, bool success)> FirstAsyncTask(this IObservable source, TimeSpan timeout) where T : class => await source.Select(val => (val, true)).Merge(Observable.Return((default(T), false)).Delay(timeout)).FirstAsync(); @@ -351,9 +365,5 @@ namespace System.Reactive.Linq public static IObservable OnDispatcher(this IObservable source) { return DispatcherObservable.ObserveOnDispatcher(source, DispatcherPriority.Background); } - - } -} - - +} \ No newline at end of file diff --git a/src/client/spark/core/Utility/KeyDrivenObservable.cs b/src/client/spark/core/Utility/KeyDrivenObservable.cs index 77d4e6296..b26f9a5d9 100644 --- a/src/client/spark/core/Utility/KeyDrivenObservable.cs +++ b/src/client/spark/core/Utility/KeyDrivenObservable.cs @@ -1,20 +1,38 @@ using System; +using System.Collections.Generic; +using System.Linq; +using System.Reactive.Linq; using System.Reactive.Subjects; namespace mbts.utils { - class KeyDrivenObservable : ISubject, IDisposable { + /// + /// Observes a sequence of s which are used to create inner sequences of s. + /// An internal subscription made to each inner sequence drives the notifications sent to outside observers. + /// When the next key arrives, the previous internal subscription is disposed. + /// Note: this behaves differently from , + /// which merges each inner sequence together, without terminating the previous one when the next key arrives. + /// + /// + /// + /// + class KeyDrivenObservableSeries : ISubject, IDisposable { readonly Func> _selector; + object _lock = new object(); Subject _value_subject = new Subject(); IDisposable _current_key_sub; - public KeyDrivenObservable(Func> selector) => + public KeyDrivenObservableSeries(Func> selector) => _selector = selector; public void OnCompleted() => Disposable.dispose(ref _current_key_sub); public void OnError(Exception error) { } public void OnNext(TKey key) { - Disposable.dispose(ref _current_key_sub); - _current_key_sub = _selector(key)?.Subscribe(_value_subject); + lock (_lock) { + // need to lock bc simultaneous callbacks on diff threads could generate 2 subscriptions at once, + // only 1 of which would get disposed in the next callback. + Disposable.dispose(ref _current_key_sub); + _current_key_sub = _selector(key)?.Subscribe(_value_subject); + } } public IDisposable Subscribe(IObserver observer) => _value_subject.Subscribe(observer); @@ -24,4 +42,69 @@ namespace mbts.utils { Disposable.dispose(ref _value_subject); } } + + /// + /// Facilitates the creation of sequences that are the product of multiple inner sequences, created by each element in the source. + /// Note: The inner sequences will be played "series," as opposed to "parallel," meaning the previous inner sequence is terminated when the next element arrives. + /// + /// The type of elements used to create a series inner sequences. + class ConnectableSeriesSource { + readonly IObservable _source; + readonly List> _observers = new List>(); + + public ConnectableSeriesSource(IObservable source) => + _source = source; + + /// + /// Creates an IConnectableObservable<TResult> sequence that is the product of multiple inner sequences created by each element in "series," terminating each inner sequence when the next one begins. + /// + /// + /// + /// + public IConnectableObservable create_connectable(Func> select_next) => + new AnonymousConnectable(_source, select_next); + + class AnonymousConnectable : IConnectableObservable { + readonly IObservable _source; + readonly KeyDrivenObservableSeries _driver; + + public AnonymousConnectable(IObservable source, Func> select_next) { + _source = source; + _driver = new KeyDrivenObservableSeries(select_next); + } + + public IDisposable Connect() => _source.Subscribe(_driver); + public IDisposable Subscribe(IObserver observer) => _driver.Subscribe(observer); + } + } + + class ConnectableSeriesBuilder { + readonly ConnectableSeriesSource _connectable_series_source; + readonly List _connect_connectables = new List(); + + public ConnectableSeriesBuilder(IObservable source) => + _connectable_series_source = new ConnectableSeriesSource(source); + + public IObservable create(Func> select_next) { + var connectable = _connectable_series_source.create_connectable(select_next); + _connect_connectables.Add(new ConnectConnectable(connectable)); + return connectable; + } + + public IDisposable connect_all() => + Disposable.Create(_connect_connectables.Select(c => c.connect()).ToArray()); + + interface IConnectConnectable { + IDisposable connect(); + } + + class ConnectConnectable : IConnectConnectable { + readonly IConnectableObservable _connectable; + + public ConnectConnectable(IConnectableObservable connectable) => + _connectable = connectable; + + public IDisposable connect() => _connectable.Connect(); + } + } } \ No newline at end of file diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index bd1cf1e28..3bc639b4a 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -44,7 +44,7 @@ namespace mbts.spark { _open = backing(nameof(open), double.NaN); _settlement = backing(nameof(settlement), double.NaN); // remember: account_positions needs to subscribe to selected_account; both the sub and account_positions need to be disposed - var account_positions = new KeyDrivenObservable(a => _model.order_gateway.security_total_position(security.Id, a)); + var account_positions = new KeyDrivenObservableSeries(a => _model.order_gateway.security_total_position(security.Id, a)); _position = backing(nameof(position), account_positions.OnDispatcher()); _volume = backing(nameof(volume), 0ul); _auto_clear = backing(nameof(auto_clear), false);