From 9b6a5ea94335f8d79e32c8721c9697a0fa4eecd8 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 25 Apr 2019 19:05:03 -0500 Subject: [PATCH] remove hacky ILazyAlgo interface, replace functionality with subscribe_is_dirty extension --- .../Trading/AlgoStudio/VM/AlgoDefinitionVM.cs | 41 +++++++++++-------- .../spark/Orders/OrderTypeVMs/IOrderTypeVM.cs | 25 ++++++++--- .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 18 ++++---- .../Orders/OrderTypeVMs/SpreaderOrderVM.cs | 15 ++++--- .../spark/core/Utility/ThresholdMonitor.cs | 8 +++- 5 files changed, 70 insertions(+), 37 deletions(-) diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs index 80e1595b5..16e2ee33b 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs @@ -131,27 +131,16 @@ namespace mbts.spark { as_demuxer().subscribe_many(_refresh_on_local_changes.execute, nameof(this.name), nameof(abbreviation), nameof(badge_fill)), _edit_pane_vs_model.add_source(VisualStateNames.BadgeSelector.GroupName, custom_badge_color.observe_nullable(true).Select(t => t.HasValue ? VisualStateNames.BadgeSelector.Active : VisualStateNames.BadgeSelector.Inactive)), _edit_pane_vs_model.add_source(VisualStateNames.Abbreviation.GroupName, _abbreviation.observe_current(true).Select(a => string.IsNullOrEmpty(a) ? VisualStateNames.Abbreviation.Unpopulated : VisualStateNames.Abbreviation.Populated)), - _algo_root.observe_current(true).SubscribeEach(vm => { - if (vm == null) - return Disposable.empty; - if (vm is ILazyAlgo la) { - bool synced_with_loaded = false; - return vm.subscribe_definition().Subscribe(_ => { - if (la.is_loaded) { - if (!synced_with_loaded) { - synced_with_loaded = true; + _algo_root.observe_current(true).SubscribeEach(vm => + vm == null ? null : + Disposable.Create( + vm.subscribe_is_dirty().Subscribe(v => { + if (!v) { _version.increment_version(); _on_committed_changed(); - } else { - _refresh_on_local_changes.execute(); } - } else { - synced_with_loaded = false; - } - }); - } - return vm.subscribe_definition().Subscribe(_ => _refresh_on_local_changes.execute()); - }), + }), + vm.subscribe_definition().Subscribe(_ => _refresh_on_local_changes.execute()))), ObservableAutoWrapper.connect_item_hooks(algo_roots, a => a as IDisposable ?? Disposable.empty, true), ObservableAutoWrapper.connect_item_hooks(templates, t => new CompositeDisposable(_any_templates_dirty_monitor.join(t), t), true), Disposable.Create(() => { @@ -442,8 +431,12 @@ namespace mbts.spark { _committed = _version.value; _is_dirty.refresh(); _refresh_undo_redo(); + RaisePropertyChanged(nameof(committed_value), nameof(current_value)); } + public Snapshot? committed_value => _committed; + public Snapshot current_value => _version.value; + IAlgoVM _mk_algo_root(CustomOrderDefinitionImmutable definition) => OrderTypeVMFactory.create(new AlgoData(definition), is_expanded: true); @@ -546,5 +539,17 @@ namespace mbts.spark { public static bool operator ==(Snapshot a, Snapshot b) => a.Equals(b); public static bool operator !=(Snapshot a, Snapshot b) => !a.Equals(b); } + + struct SnapshotTemplateEqualityComparer : IEqualityComparer { + public bool Equals(Snapshot x, Snapshot y) => + x.abbreviation == y.abbreviation && + x.custom_badge_color == y.custom_badge_color && + x.format == y.format && + x.data.key == y.data.key && + x.data.name == y.data.name && + x.data.value.Equals(y.data.value); + + public int GetHashCode(Snapshot obj) => throw new NotImplementedException(); + } } } diff --git a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs index 5d029eeb5..bd1b5c0a3 100644 --- a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs @@ -62,12 +62,6 @@ namespace mbts.spark { IAlgoVM impl { get; } } - delegate void AlgoLoaded(bool reset_edit_stack); - - interface ILazyAlgo { - bool is_loaded { get; } - } - interface IAlgoParamVM { event Action is_dirty_changed; event PropertyChange permissions_changed; @@ -136,6 +130,25 @@ namespace mbts.spark { public static IEnumerable enumerate_all_params(this IAlgoVM vm) => vm == null ? Enumerable.Empty() : vm.algo_params.Concat(vm.child_algo_selectors.SelectMany(s => enumerate_all_params(s.selected_algo))); + public static IObservable subscribe_is_dirty(this IAlgoParamVM param_vm) => + Observable.Create(o => { + o.OnNext(param_vm.is_dirty); + param_vm.is_dirty_changed += o.OnNext; + return Disposable.Create(dispose); + void dispose() => param_vm.is_dirty_changed -= o.OnNext; + }); + + public static IObservable subscribe_is_dirty(this IAlgoVM vm) => + Observable.Create(o => { + var mon = new ReactiveThresholdMonitor(); + return Disposable.Create( + ObservableAutoWrapper.connect_item_hooks(vm.child_algo_selectors, set_selector_hooks), + ObservableAutoWrapper.connect_item_hooks(vm.algo_params, p => mon.join(p.id, p.subscribe_is_dirty())), + mon.Subscribe(o)); + IDisposable set_selector_hooks(IAlgoSelector s) => + s.subscribe_selected_algo().SubscribeEach(_vm => mon.join(s.id, _vm.subscribe_is_dirty())); + }); + public static IObservable subscribe_permissions(this IAlgoParamVM param_vm) => Observable.Create(o => { o.OnNext(param_vm.permissions); diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index 710862dce..7c83efe81 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -504,24 +504,28 @@ namespace mbts.spark { } } - protected Property add_property(string prop_name, Func get_from_def, Action assign_to_def, TValue init_value = default, AlgoParamPermissions permissions = AlgoParamPermissions.ReadWrite) { + protected Property add_property(string prop_name, Func get_from_def, Action assign_to_def, TValue init_value = default, AlgoParamPermissions permissions = AlgoParamPermissions.ReadWrite) => + add_property(prop_name, get_from_def, assign_to_def, out AlgoParamVM param, init_value, permissions); + + protected Property add_property(string prop_name, Func get_from_def, Action assign_to_def, out AlgoParamVM param, TValue init_value = default, AlgoParamPermissions permissions = AlgoParamPermissions.ReadWrite) { var prop = backing(prop_name, init_value); - var param = new AlgoParamVM(prop_name, prop_name, init_value) { permissions = permissions }; - _link_props(param, prop); - _algo_params.Add(param); + var local_param = new AlgoParamVM(prop_name, prop_name, init_value) { permissions = permissions }; + param = local_param; + _link_props(local_param, prop); + _algo_params.Add(local_param); _auto_props.Add(new AutoProp( prop_name, def => { - if (param.has_value) + if (local_param.has_value) assign_to_def(def, prop.Value); }, def => assign_to_prop_and_commit(get_from_def(def)), algos => assign_to_prop_and_commit(algos.Select(get_from_def).Distinct().SafeSingleOrDefault()), - _link_props(param, prop))); + _link_props(local_param, prop))); return prop; void assign_to_prop_and_commit(TValue value) { prop.set(value); - param.mark_committed(); + local_param.mark_committed(); } } diff --git a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs index aa0473a09..0b2f95e14 100644 --- a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs @@ -1,6 +1,8 @@ using bts; +using bts.api; using bts.api.orderman; using bts.collections; +using bts.spark; using mbts.ui.controls; using mbts.ui.shell; using mbts.ui.utility; @@ -13,9 +15,10 @@ using SpreaderDefi = bts.api.orderman.SpreaderOrderDefinitionImmutable; namespace mbts.spark { static partial class OrderTypeVMFactory { - class SpreaderOrderVM : OrderTypeVMBase, IAlgoVM, ILazyAlgo, IObserver { + class SpreaderOrderVM : OrderTypeVMBase, IAlgoVM, IObserver { readonly IProperty _template; readonly StrategyEditorWrapper _strategy_editor_wrapper; + readonly AlgoParamVM _strategy_param; IDisposable _strategy_sub; public SpreaderOrderVM(AlgoKey key, string display_name, AlgoEditingPermissions editing_permissions) @@ -23,9 +26,12 @@ namespace mbts.spark { _template = backing(nameof(template)).block_reentrancy(); /// depends on (i.e. initialize the latter first). _strategy_editor_wrapper = new StrategyEditorWrapper(this); - var strategy_prop = add_property(nameof(SpreaderDef.ExecutionStrategy), mdef => mdef.ExecutionStrategy, (mdef, val) => mdef.ExecutionStrategy = val); - var security_prop = add_property(nameof(SpreaderDef.Security), mdef => mdef.Security, (mdef, val) => mdef.Security = val, permissions: AlgoParamPermissions.None); + var strategy_prop = add_property(nameof(SpreaderDef.ExecutionStrategy), mdef => mdef.ExecutionStrategy, (mdef, val) => mdef.ExecutionStrategy = val, out _strategy_param); + _strategy_param.mark_committed(); + var security_prop = add_property(nameof(SpreaderDef.Security), mdef => mdef.Security, (mdef, val) => mdef.Security = val, out AlgoParamVM security_param, permissions: AlgoParamPermissions.None); + security_param.mark_committed(); _resources.AddRange( + security_param.subscribe_value().Subscribe(_ => security_param.mark_committed()), _strategy_editor_wrapper, _template.Subscribe(vals => validate()), _template.Subscribe(ch => security_prop.Value = ch.newval.HasValue && ch.newval.Value.HasSecurity ? ch.newval.Value.Security.CloneToMutable() : null), _template.Subscribe(ch => strategy_prop.Value = ch.newval.HasValue && ch.newval.Value.HasExecutionStrategy ? ch.newval.Value.ExecutionStrategy.CloneToMutable() : null), @@ -57,7 +63,6 @@ namespace mbts.spark { base.is_expanded = value; } } - public bool is_loaded { get; private set; } protected override void validate() { base.validate(); @@ -76,8 +81,8 @@ namespace mbts.spark { .Select(strategy => new SpreaderDefi?(model.factory.spreader_orderi(security.Value, strategy))) .OnDispatcher() .Subscribe(s => { - is_loaded = true; _template.Value = s; + _strategy_param.mark_committed(); }); } } diff --git a/src/client/spark/core/Utility/ThresholdMonitor.cs b/src/client/spark/core/Utility/ThresholdMonitor.cs index 46898a652..def7aee2b 100644 --- a/src/client/spark/core/Utility/ThresholdMonitor.cs +++ b/src/client/spark/core/Utility/ThresholdMonitor.cs @@ -42,6 +42,9 @@ namespace mbts.utils { readonly Func> _subscribe_item; uint _threshold; + public ReactiveThresholdMonitor() + : this(null, EqualityComparer.Default) { } + public ReactiveThresholdMonitor(Func> subscribe_item) : this(subscribe_item, EqualityComparer.Default) { } @@ -60,7 +63,10 @@ namespace mbts.utils { } public IDisposable join(T item) => - new CompositeDisposable(_subscribe_item(item).Subscribe(val => { + _subscribe_item == null ? throw new InvalidOperationException("No 'subscribe-item' delegate was specified in the constructor.") : join(item, _subscribe_item(item)); + + public IDisposable join(T item, IObservable source) => + new CompositeDisposable(source.Subscribe(val => { using (_begin_update()) { if (val) _filtered_items.Add(item); else _filtered_items.Remove(item);