replace improper .SelectMany subscriptions to the viewmodel in SparkWindows

This commit is contained in:
John Colvin committed 2018-09-04 19:06:24 -04:00
1 parent 9623a015df
commit 2bfaf8305a
6 files changed
+128 -24

No files matched your search

@@ -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<MarketViewVM.Row, SecurityMD> {
@@ -19,10 +19,11 @@ namespace mbts.spark {
readonly OrdersModel _orders_model;
public MarketViewVM(IBus bus, OrdersModel orders_model, IObservable<StartupData> state)
: this(bus, orders_model, state, new KeyDrivenObservable<SecurityCriteria, IEnumerable<SecurityMD>>(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<StartupData> state, KeyDrivenObservable<SecurityCriteria, IEnumerable<SecurityMD>> 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<StartupData> state, IConnectableObservable<IEnumerable<SecurityMD>> securities_connectable)
: base(RXCollection.Create(securities_connectable, SecurityDataHelper.EqualityComparer.MDComparer), null) {
_bus = bus;
_orders_model = orders_model;
security_filter = new RegexFilterVM<Row>(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)
);
}
@@ -57,9 +57,10 @@ namespace mbts.spark {
public void thread_init() {
_dispose_resources();
_vm = new SingleValuePump<TimeAndSalesVM>();
var connectable_builder = new ConnectableSeriesBuilder<TimeAndSalesVM>(_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>(T _) => true;
@@ -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<SyntheticManagementDialogVM>(_vm.observable);
var current_row_source = vm_connectable_builder.create(vm => vm.current_row_observable);
var current_row_connectable_builder = new ConnectableSeriesBuilder<SyntheticManagementDialogVM.Row>(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<RowModificationParams?> 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));
@@ -334,6 +334,20 @@ namespace System.Reactive.Linq
public static IObservable<(TSource prev, TSource curr)> PairWithPrevious<TSource>(this IObservable<TSource> source, TSource default_value) =>
source.Scan<TSource, (TSource prev, TSource curr)>((default_value, default_value), (last, next) => (last.curr, next));
/// <summary>
/// Uses each element of a source observable to create an inner observable of <typeparamref name="TResult"/>, unlike <see cref="Observable.SelectMany{TSource, TResult}(IObservable{TSource}, Func{TSource, IObservable{TResult}})"/>,
/// each inner sequence is terminated when the next one begins.
/// <para/>In other words, observers are notified by the inner observerables in &quot;series,&quot; rather than &quot;parallel.&quot;
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="select_next"></param>
/// <param name="source_sub"></param>
/// <returns></returns>
public static IConnectableObservable<TResult> SelectManyInSeries<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> select_next) =>
new ConnectableSeriesSource<TSource>(source).create_connectable(select_next);
public static async Task<(T result, bool success)> FirstAsyncTask<T>(this IObservable<T> 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<T> OnDispatcher<T>(this IObservable<T> source) {
return DispatcherObservable.ObserveOnDispatcher(source, DispatcherPriority.Background);
}
}
}
}
@@ -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<TKey, TValue> : ISubject<TKey, TValue>, IDisposable {
/// <summary>
/// Observes a sequence of <typeparamref name="TKey"/>s which are used to create inner sequences of <typeparamref name="TValue"/>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.
/// <para/>Note: this behaves differently from <see cref="Observable.SelectMany{TSource, TResult}(IObservable{TSource}, Func{TSource, int, IObservable{TResult}})"/>,
/// which merges each inner sequence together, without terminating the previous one when the next key arrives.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <seealso cref="Observable.SelectMany"/>
class KeyDrivenObservableSeries<TKey, TValue> : ISubject<TKey, TValue>, IDisposable {
readonly Func<TKey, IObservable<TValue>> _selector;
object _lock = new object();
Subject<TValue> _value_subject = new Subject<TValue>();
IDisposable _current_key_sub;
public KeyDrivenObservable(Func<TKey, IObservable<TValue>> selector) =>
public KeyDrivenObservableSeries(Func<TKey, IObservable<TValue>> 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<TValue> observer) => _value_subject.Subscribe(observer);
@@ -24,4 +42,69 @@ namespace mbts.utils {
Disposable.dispose(ref _value_subject);
}
}
/// <summary>
/// Facilitates the creation of <see cref="IConnectableObservable{T}"/> sequences that are the product of multiple inner sequences, created by each <typeparamref name="TSource"/> element in the source.
/// <para/>Note: The inner sequences will be played &quot;series,&quot; as opposed to &quot;parallel,&quot; meaning the previous inner sequence is terminated when the next <typeparamref name="TSource"/> element arrives.
/// </summary>
/// <typeparam name="TSource">The type of elements used to create a series inner sequences.</typeparam>
class ConnectableSeriesSource<TSource> {
readonly IObservable<TSource> _source;
readonly List<IObserver<TSource>> _observers = new List<IObserver<TSource>>();
public ConnectableSeriesSource(IObservable<TSource> source) =>
_source = source;
/// <summary>
/// Creates an IConnectableObservable&lt;TResult&gt; sequence that is the product of multiple inner sequences created by each <typeparamref name="TSource"/> element in &quot;series,&quot; terminating each inner sequence when the next one begins.
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="select_next"></param>
/// <returns></returns>
public IConnectableObservable<TResult> create_connectable<TResult>(Func<TSource, IObservable<TResult>> select_next) =>
new AnonymousConnectable<TResult>(_source, select_next);
class AnonymousConnectable<TResult> : IConnectableObservable<TResult> {
readonly IObservable<TSource> _source;
readonly KeyDrivenObservableSeries<TSource, TResult> _driver;
public AnonymousConnectable(IObservable<TSource> source, Func<TSource, IObservable<TResult>> select_next) {
_source = source;
_driver = new KeyDrivenObservableSeries<TSource, TResult>(select_next);
}
public IDisposable Connect() => _source.Subscribe(_driver);
public IDisposable Subscribe(IObserver<TResult> observer) => _driver.Subscribe(observer);
}
}
class ConnectableSeriesBuilder<TSource> {
readonly ConnectableSeriesSource<TSource> _connectable_series_source;
readonly List<IConnectConnectable> _connect_connectables = new List<IConnectConnectable>();
public ConnectableSeriesBuilder(IObservable<TSource> source) =>
_connectable_series_source = new ConnectableSeriesSource<TSource>(source);
public IObservable<TResult> create<TResult>(Func<TSource, IObservable<TResult>> select_next) {
var connectable = _connectable_series_source.create_connectable(select_next);
_connect_connectables.Add(new ConnectConnectable<TResult>(connectable));
return connectable;
}
public IDisposable connect_all() =>
Disposable.Create(_connect_connectables.Select(c => c.connect()).ToArray());
interface IConnectConnectable {
IDisposable connect();
}
class ConnectConnectable<T> : IConnectConnectable {
readonly IConnectableObservable<T> _connectable;
public ConnectConnectable(IConnectableObservable<T> connectable) =>
_connectable = connectable;
public IDisposable connect() => _connectable.Connect();
}
}
}
@@ -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<string, double>(a => _model.order_gateway.security_total_position(security.Id, a));
var account_positions = new KeyDrivenObservableSeries<string, double>(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);