AlgoStudio/Ladder - remove esoteric OrderTypeCollection, use ObservableKeyedCollection and handle updates internally instead

This commit is contained in:
John Colvin committed 2019-02-05 12:40:52 -06:00
1 parent c195df220c
commit d1be1ec488
5 files changed
+82 -68

No files matched your search

@@ -35,7 +35,7 @@ namespace mbts.spark {
readonly Property<AlgoDefinitionTemplateVM> _selected_template;
readonly DelegateProperty<bool> _is_favorite, _is_dirty, _can_undo, _can_redo;
readonly Property<string> _abbreviation;
readonly OrderTypeVMCollection _algo_roots;
readonly ObservableKeyedCollection<IOrderTypeVM, string> _algo_roots = new ObservableKeyedCollection<IOrderTypeVM, string>(vm => vm.id);
readonly ObservableAppendCollection<AlgoDefinitionTemplateVM> _templates_with_custom;
readonly DeferrableActionWrapper _refresh_on_local_changes;
readonly ReactiveThresholdMonitor<AlgoDefinitionTemplateVM> _any_templates_dirty_monitor = new ReactiveThresholdMonitor<AlgoDefinitionTemplateVM>(t => t.observe_is_dirty());
@@ -70,7 +70,6 @@ namespace mbts.spark {
custom_badge_color_palettes.AddRange(ColorPalette.all_presets(model.factory).Select(p => new ColorPaletteVM(p)));
_abbreviation = backing(nameof(abbreviation), string.Empty);
_template_update_buffer = new TableUpdateBuffer<AlgoTemplateData, AlgoPersistedKey>(t => t.key);
_algo_roots = new OrderTypeVMCollection(_model);
_algo_root = backing(nameof(algo_root), _algo_roots.GetOrAdd(init_algo_root.id, _ => OrderTypeVMFactory.create(_model, this.security_md_source, init_algo_root, _editing_permissions)));
algo_root.load_from(init_algo_root.definition);
_templates_with_custom = new ObservableAppendCollection<AlgoDefinitionTemplateVM>(templates);
@@ -127,7 +126,9 @@ namespace mbts.spark {
resources.Add(model.algo_model.metadata_service.subscribe_metadata(vm_key.persisted_id).OnDispatcher().Subscribe(_on_metadata));
break;
case AlgoVMKey.Mode.LegacyFlex:
resources.Add(_algo_roots.connect_security_md(security_md_source));
resources.Add(security_md_source.Subscribe(smd =>
_algo_roots.SyncWithDictionary(_model.factory.default_order_type_templates(smd.security()),
nd => OrderTypeVMFactory.create(_model, security_md_source, nd, _editing_permissions, true))));
_version.increment_version();
_committed = _version.value;
_edit_stack.reset(_committed.Value);
@@ -146,7 +147,11 @@ namespace mbts.spark {
on_editing_permissions(_get_permissions(templates.Count));
}
// local methods
void on_editing_permissions(OrderTypeEditingPermissions eps) => _algo_roots.on_editing_permissions(_editing_permissions = eps);
void on_editing_permissions(OrderTypeEditingPermissions eps) {
_editing_permissions = eps;
foreach (var vm in algo_roots)
vm.set_permissions(eps);
}
void on_can_redo_changed(bool oldval, bool newval) => can_redo_changed?.Invoke();
void on_can_undo_changed(bool oldval, bool newval) => can_undo_changed?.Invoke();
}
@@ -0,0 +1,19 @@
using bts.api.orderman;
namespace mbts.spark {
struct NamedCustomOrderDefinition {
public readonly string id, display_name;
public readonly CustomOrderDefinitionImmutable definition;
public NamedCustomOrderDefinition(CustomOrderDefinitionImmutable definition)
: this(definition.CustomCase.type_id(), definition.CustomCase.display_name(), definition) { }
public NamedCustomOrderDefinition(CompositeAlgoRecordImmutable record)
: this(record.AlgoDefinition.Algo) { }
public NamedCustomOrderDefinition(string id, string display_name, CustomOrderDefinitionImmutable definition) {
this.id = id;
this.display_name = display_name;
this.definition = definition;
}
}
}
@@ -1,42 +0,0 @@
using bts.api.orderman;
using mbts.collections;
using System;
using System.Reactive.Linq;
namespace mbts.spark {
struct NamedCustomOrderDefinition {
public readonly string id, display_name;
public readonly CustomOrderDefinitionImmutable definition;
public NamedCustomOrderDefinition(CustomOrderDefinitionImmutable definition)
: this(definition.CustomCase.type_id(), definition.CustomCase.display_name(), definition) { }
public NamedCustomOrderDefinition(CompositeAlgoRecordImmutable record)
: this(record.AlgoDefinition.Algo) { }
public NamedCustomOrderDefinition(string id, string display_name, CustomOrderDefinitionImmutable definition) {
this.id = id;
this.display_name = display_name;
this.definition = definition;
}
}
class OrderTypeVMCollection : ObservableKeyedCollection<IOrderTypeVM, string> {
readonly OrdersModel _model;
OrderTypeEditingPermissions _editing_permissions;
public OrderTypeVMCollection(OrdersModel model) : base(vm => vm.id) =>
_model = model;
public IDisposable connect_security_md(IObservable<SecurityMD?> source) =>
source.Subscribe(security_md =>
SyncWith(_model.factory.default_order_type_templates(security_md.security()),
nd => OrderTypeVMFactory.create(_model, source, nd, _editing_permissions, true),
(nd, vm) => { /*do NOT update (overwrite) existing ordervms' definitions*/ }));
public void on_editing_permissions(OrderTypeEditingPermissions value) {
_editing_permissions = value;
foreach (var vm in this)
vm.set_permissions(value);
}
}
}
@@ -1,6 +1,7 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
using mbts.collections;
using mbts.spark.utilities;
using mbts.ui.shell;
using mbts.ui.utility;
@@ -235,7 +236,7 @@ namespace mbts.spark {
readonly IValidationViewModel _owner;
readonly OrdersModel _model;
readonly IObservable<SecurityMD?> _security_md_source;
readonly OrderTypeVMCollection _order_types;
readonly ObservableKeyedCollection<IOrderTypeVM, string> _order_types = new ObservableKeyedCollection<IOrderTypeVM, string>(vm => vm.id);
readonly Action _raise_definition_changed;
readonly EventHandler<DataErrorsChangedEventArgs> _on_errors_changed;
readonly Dictionary<IOrderTypeVM, DisposableContainer> _order_type_hooks = new Dictionary<IOrderTypeVM, DisposableContainer>();
@@ -246,11 +247,10 @@ namespace mbts.spark {
public OrderSelector(IValidationViewModel owner, string prop_name, OrdersModel model, IObservable<SecurityMD?> security_md_source, OrderTypeEditingPermissions editing_permissions, Action raise_definition_changed, EventHandler<DataErrorsChangedEventArgs> on_errors_changed) {
_owner = owner;
_prop_name = prop_name;
_order_types = new OrderTypeVMCollection(_model = model);
_model = model;
_security_md_source = security_md_source;
_on_errors_changed = on_errors_changed;
_raise_definition_changed = raise_definition_changed;
_order_types.on_editing_permissions(_editing_permissions = editing_permissions);
}
public ICollection<IOrderTypeVM> order_types => _order_types;
@@ -259,8 +259,11 @@ namespace mbts.spark {
/// Subscribe to securities if we haven't already (this must be done lazily to avoid a <see cref="StackOverflowException"/>).
/// The security dictates the available definition templates.
/// For ex: synthetics need a Spreader vm, but not a Limit vm. Vice versa for futures.
if (_security_sub == null)
_security_sub = _order_types.connect_security_md(_security_md_source);
if (_security_sub == null) {
_security_sub = _security_md_source.Subscribe(
smd => _order_types.SyncWithDictionary(_model.factory.default_order_type_templates(smd.security()),
nd => create(_model, _security_md_source, nd, _editing_permissions, true)));
}
return _order;
}
set {
@@ -296,8 +299,11 @@ namespace mbts.spark {
_order_types.Clear();
}
public void propagate_permissions(OrderTypeEditingPermissions editing_permissions) =>
_order_types.on_editing_permissions(_editing_permissions = editing_permissions);
public void propagate_permissions(OrderTypeEditingPermissions editing_permissions) {
_editing_permissions = editing_permissions;
foreach (var vm in _order_types)
vm.set_permissions(editing_permissions);
}
void _select_order(IOrderTypeVM newval) {
if (newval == _order) return;
@@ -1,4 +1,5 @@
using System;
using bts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
@@ -90,11 +91,46 @@ namespace mbts.collections {
return false;
}
public void SyncWith<TModel>(IReadOnlyDictionary<TKey, TModel> dictionary, Func<TModel, T> factory, Action<TModel, T> update, Func<TKey, bool> ignore_remove = null) {
foreach (var k in _map.Keys.Except(dictionary.Keys).ToList()) {
if (ignore_remove == null || !ignore_remove(k))
Remove(k);
public void SyncWithKeys(IEnumerable<TKey> keys, Func<TKey, T> factory) {
var keys_list = new List<TKey>(keys);
var changes = Diff.diff(this.Keys, keys).ToList();
int ch_count = changes.Count;
for (int ch_pos = 0; ch_pos < ch_count; ch_pos++) {
var ch = changes[ch_pos];
for (int i = ch.StartLeft; i < (ch.StartLeft + ch.deletedLeft); i++)
RemoveAt(i);
for (int i = 0; i < ch.insertedRight; i++) {
var k = keys_list[ch.StartRight + i];
var v = factory(k);
int index = ch.StartLeft + i;
Items.Insert(index, v);
_map.Add(k, v);
_notify_props_changed();
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, v, index));
}
for (int i = ch_pos + 1; i < ch_count; i++) {
// (f)orward (ch)ange
var fch = changes[i];
if (fch.StartLeft >= ch.StartLeft) {
fch.StartLeft += (fch.insertedRight - fch.deletedLeft);
changes[i] = fch;
}
}
}
}
public void SyncWithDictionary<TModel>(IReadOnlyDictionary<TKey, TModel> dictionary, Func<TModel, T> factory) {
foreach (var k in _map.Keys.Except(dictionary.Keys).ToList())
Remove(k);
foreach (var kv in dictionary) {
if (!ContainsKey(kv.Key))
Add(factory(kv.Value));
}
}
public void SyncWithDictionary<TModel>(IReadOnlyDictionary<TKey, TModel> dictionary, Func<TModel, T> factory, Action<TModel, T> update) {
foreach (var k in _map.Keys.Except(dictionary.Keys).ToList())
Remove(k);
foreach (var kv in dictionary) {
if (TryGetValue(kv.Key, out T curr))
update(kv.Value, curr);
@@ -159,14 +195,4 @@ namespace mbts.collections {
}
}
}
class LazyKeyedCollectionWrapper<T, TKey, TSource> : ObservableKeyedCollection<T, TKey> {
public LazyKeyedCollectionWrapper(Func<T, TKey> key)
: this(key, EqualityComparer<TKey>.Default) { }
public LazyKeyedCollectionWrapper(Func<T, TKey> key, IEqualityComparer<TKey> key_comparer)
: base(key, key_comparer) {
}
}
}