diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs index 50ad47fe2..58f92670c 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs @@ -10,7 +10,7 @@ namespace mbts.spark { public readonly AlgoKey key; public AlgoData(CustomOrderDefinitionImmutable value) - : this(value, value.CustomCase.display_name(), new AlgoKey(value.CustomCase)) { } + : this(value, value.display_name(), OrderDataHelper.get_shallow_factory_key(value)) { } public AlgoData(CustomOrderDefinitionImmutable value, string name, AlgoKey key) { this.value = value; diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs index fff917a91..fb2c0666e 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs @@ -72,7 +72,7 @@ namespace mbts.spark { _build_structure(definition.CloneToMutable(), ref structure, pos); static void _build_structure(CustomOrderDefinition algo, ref int[] structure, int pos) { - var cad = OrderDataHelper.get_child_algo_data(algo.CustomCase); + var cad = OrderDataHelper.get_child_algo_data(algo); for (int di = 0; di < cad.Count; di++) { if (cad[di].get_child(algo) is CustomOrderDefinition child_algo) { ArrayHelper.ensure_capacity(ref structure, pos + 1); @@ -87,7 +87,7 @@ namespace mbts.spark { static void _build_def(int[] structure, ref int pos, ref CustomOrderDefinition algo) { for (int i = pos; i < structure.Length; i++) { - var cad = OrderDataHelper.get_child_algo_data(algo.CustomCase); + var cad = OrderDataHelper.get_child_algo_data(algo); for (int di = 0; di < cad.Count; di++) { int mask = 1 << (31 - di); if ((structure[i] & mask) == mask) { @@ -95,10 +95,10 @@ namespace mbts.spark { var child_algo = OrderDataHelper.Defaults.CustomOrderDefinition(type); pos++; _build_def(structure, ref pos, ref child_algo); - cad[di].set_child(algo, child_algo); + cad[di].assign_child(algo, child_algo); } } } } } -} \ No newline at end of file +} diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs index 298ccb345..308a29fbc 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs @@ -1,5 +1,8 @@ using bts.api; using bts.api.orderman; +using bts.utils; +using Google.Protobuf.Reflection; +using mbts.utils; using System; using System.Collections.Generic; using System.ComponentModel.Composition; @@ -10,6 +13,9 @@ namespace mbts.spark { [Export] public class DynamicOrderHelper { + static readonly IReadOnlyDictionary _descriptor_case_index = + ProtoHelper.get_oneof_descriptor_index(nameof(DynamicOrderParam.ValueCase)); + readonly RegisteredDynamicOrderTypes _dynamic_types; [ImportingConstructor] private DynamicOrderHelper(OrderService order_service) @@ -28,11 +34,47 @@ namespace mbts.spark { foreach(var p in d.ParamDesc) dorder.Dynamic.OrderParams.Add( p.ParamName, new DynamicOrderParam() ); defs.Add(new CustomOrderDefinitionImmutable(dorder)); - var de = get_descriptor(""); } } internal DynamicOrderDescriptor get_descriptor(string dynamic_type) => - _dynamic_types.DynamicOrderDesc.FirstOrDefault(d => d.DynamicOrderType == dynamic_type); + _dynamic_types.DynamicOrderDesc.FirstOrDefault(d => d.DynamicOrderType == dynamic_type) ?? new DynamicOrderDescriptor(); + + internal DynamicOrderDefinition create_def(string dynamic_type) { + var desc = get_descriptor(dynamic_type); + var def = new DynamicOrderDefinition(); + foreach (var p in desc.ParamDesc) { + if (_is_child_algo_desc(p)) { + def.OrderParams[p.ParamName] = new DynamicOrderParam { AsOrderDef = new CustomOrderDefinition() }; + } else if (_is_value_param_desc(p)) { + var value_case = _get_value_case(p.ParamType.Primitive); + if (_descriptor_case_index.TryGetValue(value_case, out (FieldDescriptor fd, Type type) tup)) { + var dop = new DynamicOrderParam(); + tup.fd.Accessor.SetValue(dop, ConvertUtils.get_default(tup.type)); + def.OrderParams[p.ParamName] = dop; + } + } + } + return def; + } + + static DynamicOrderParam.ValueOneofCase _get_value_case(DynamicOrderPrimitiveDescriptor primitive_descriptor_case) { + switch (primitive_descriptor_case) { + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveBool: return DynamicOrderParam.ValueOneofCase.AsBool; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveDouble: return DynamicOrderParam.ValueOneofCase.AsBool; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveInt: return DynamicOrderParam.ValueOneofCase.AsInt32; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveUint: return DynamicOrderParam.ValueOneofCase.AsUint32; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveString: return DynamicOrderParam.ValueOneofCase.AsString; + default: throw ExceptionBuilder.Argument.unexpected_case(primitive_descriptor_case, nameof(primitive_descriptor_case)); + } + } + + static bool _is_child_algo_desc(DynamicOrderParamDescriptor desc) => + desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive && + desc.ParamType.Primitive == DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef; + + static bool _is_value_param_desc(DynamicOrderParamDescriptor desc) => + desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Enumerated || + (desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive && desc.ParamType.Primitive != DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef); } -} \ No newline at end of file +} diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs index 62cf4c644..f436e7906 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs @@ -1,28 +1,36 @@ using bts.api.orderman; using mbts.collections; -using mbts.ui; -using mbts.ui.shell; +using mbts.spark.utilities; using mbts.ui.utility; using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; -using System.Threading.Tasks; +using System.Linq; +using System.Reactive.Linq; namespace mbts.spark { static partial class OrderTypeVMFactory { class DynamicOrderVM : OrderTypeVMBase { readonly ObservableKeyedCollection _parameters = new ObservableKeyedCollection(vm => vm.descriptor.ParamName); readonly Property _dyn_type; - OrdersModel _model; - bool _active; public DynamicOrderVM(AlgoKey key, string dyn_type, string display_name, AlgoEditingPermissions editing_permissions) : base(key, display_name, editing_permissions) { _dyn_type = add_property(nameof(this.dyn_type), DynamicOrderDefinition.DynamicOrderTypeFieldNumber, dyn_type); _parameters = new ObservableKeyedCollection(vm => vm.descriptor.ParamName); _resources.AddRange( - _dyn_type.Subscribe(_ => _reset_dynamic_types()), + _dyn_type.Subscribe(_ => { + _sync_dynamic_params(); + sync_selectors(); + }), + ObservableAutoWrapper.connect_item_hooks(_parameters.AsCollection(), pvm => { + add_property(pvm.descriptor.ParamName, mdef => mdef.OrderParams[pvm.descriptor.ParamName] = pvm.param, mdef => { + if (mdef.OrderParams.TryGetValue(pvm.descriptor.ParamName, out DynamicOrderParam p)) + pvm.param = p; + }); + return Disposable.Create(() => remove_property(pvm.descriptor.ParamName)); + }), ObservableAutoWrapper.connect_item_hooks(_parameters, p => { p.PropertyChanged += on_param_prop_changed; return Disposable.Create(() => p.PropertyChanged -= on_param_prop_changed); @@ -31,103 +39,26 @@ namespace mbts.spark { } public string dyn_type => _dyn_type.Value; - public ObservableCollection parameters { - get { - _ensure_init(); - return _parameters; + public ObservableCollection parameters => _parameters; + + protected override void on_model_internal() => + _sync_dynamic_params(); + + protected override IEnumerable get_selector_datum() => + OrderDataHelper.get_child_algo_data(new CustomOrderDefinition { + Dynamic = model?.dynamic_helper?.create_def(dyn_type) ?? new DynamicOrderDefinition() + }); + + void _sync_dynamic_params() { + if (model != null) { + var desc = model.dynamic_helper.get_descriptor(dyn_type); + _parameters.SyncWithDictionary(desc.ParamDesc.Where(_is_value_param_desc).ToDictionary(p => p.ParamName), DynamicOrderParamVM.create); } } - protected override void assign_to_internal(DynamicOrderDefinition dynamic_def) { - foreach (var vm in _parameters.Values) - dynamic_def.OrderParams[vm.descriptor.ParamName] = vm.param; - } - - protected override void load_from_internal(DynamicOrderDefinitionImmutable dyn_defi) { - foreach (var p in _parameters) { - if (dyn_defi.OrderParams.TryGetValue(p.descriptor.ParamName, out DynamicOrderParam dop)) { - p.param = dop; - } else { - p.param.ClearValue(); - } - } - } - - protected override async Task on_load_from_async(CustomOrderDefinitionImmutable defi) { - await Wait.until_true(() => _model != null, TimeSpan.FromSeconds(60)); - _ensure_init(); - } - - void _ensure_init() { - if (!_active) { - _active = true; - // lazy initialization is required to avoid a stack overflow (otherwise, the algo-hierarchy would grow recursively without stopping). - _reset_dynamic_types(); - } - } - protected override void on_model_internal(OrdersModel model) { - _model = model; - _reset_dynamic_types(); - } - - void _reset_dynamic_types() { - if (!_active) - return; - var value_descs = new Dictionary(); - var child_descs = new Dictionary(); - if (_model != null) { - var desc = _model.dynamic_helper.get_descriptor(dyn_type); - if (desc != null) { - foreach (var p in desc.ParamDesc) { - if (_is_value_param_desc(p)) { - value_descs[p.ParamName] = p; - } else if (_is_child_algo_desc(p)) { - child_descs[p.ParamName] = p; - } - } - } - } - _parameters.SyncWithDictionary(value_descs, DynamicOrderParamVM.create); - using (reset_selectors()) { - foreach (var kv in child_descs) { - add_selector(kv.Key, get_child, set_child); - // local methods - CustomOrderDefinitionImmutable? get_child(DynamicOrderDefinitionImmutable dyn_defi) { - if (dyn_defi.OrderParams.TryGetValue(kv.Key, out DynamicOrderParam p) && p.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef) - return new CustomOrderDefinitionImmutable(p.AsOrderDef); - return null; - } - void set_child(DynamicOrderDefinition dyn_def, CustomOrderDefinition child) => - dyn_def.OrderParams[kv.Key] = new DynamicOrderParam { AsOrderDef = child }; - } - } - } - - static bool _is_child_algo_desc(DynamicOrderParamDescriptor desc) => - desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive && - desc.ParamType.Primitive == DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef; - static bool _is_value_param_desc(DynamicOrderParamDescriptor desc) => desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Enumerated || (desc.ParamType.DescriptorCase == DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive && desc.ParamType.Primitive != DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef); - - public class SelectorVM : ViewModelBase { - readonly IAlgoSelector _selector; - - public SelectorVM(IAlgoSelector selector) { - _selector = selector; - _selector.selected_algo_changed += _on_selected_algo_changed; - } - - public IAlgoVM selected_algo { get => _selector.selected_algo; set => _selector.selected_algo = value; } - public ObservableCollection algos => _selector.algos; - - public void Dispose() => - _selector.selected_algo_changed -= _on_selected_algo_changed; - - void _on_selected_algo_changed(IAlgoVM oldval, IAlgoVM newval) => - RaisePropertyChanged(nameof(selected_algo)); - } } } } diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index dd404cc99..3dfaea3de 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -113,11 +113,12 @@ namespace mbts.spark { readonly IDictionary _children_vm = new ExpandoObject(); protected CompositeDisposable _resources = new CompositeDisposable(); - readonly List<(Action assign, Action load)> _auto_props = new List<(Action assign, Action load)>(); + readonly ObservableKeyedCollection<(string name, Action assign, Action load), string> _auto_props = new ObservableKeyedCollection<(string name, Action assign, Action load), string>(t => t.name); readonly ObservableKeyedCollection _child_algo_selector_data = new ObservableKeyedCollection(sd => sd.prop_name); readonly ObservableAutoWrapper _child_algo_selectors; readonly Property _is_expanded, _can_save_values, _can_save_structure; readonly DeferrableActionWrapper _def_change_notifier; + IDisposable _pending_load; protected OrderTypeVMBase(AlgoKey id, string display_name, AlgoEditingPermissions editing_permissions) { this.id = id; @@ -127,9 +128,7 @@ namespace mbts.spark { _can_save_values = backing(nameof(can_save_values), true); _can_save_structure = backing(nameof(can_save_structure), true); _is_expanded = backing(nameof(is_expanded)); - foreach (var c in OrderDataHelper.get_child_algo_data(order_type)) { - _children_vm[c.name] = add_selector(c.name, c.descriptor); - } + meta = OrderDataHelper.get_metadata(order_type); _def_change_notifier = new DeferrableActionWrapper(() => definition_changed?.Invoke()); PropertyChanged += (s, e) => { switch (e.PropertyName) { @@ -170,39 +169,41 @@ namespace mbts.spark { }, true)); } - public AlgoEditingPermissions editing_permissions { get; private set; } public event Action definition_changed; + // core public AlgoDefi definition => new AlgoDefi(this.created_assigned()); public AlgoType order_type => OrderDataHelper.get_order_type(new TMutable()); - public bool is_bts_type => display_name.StartsWith("BTS"); public AlgoKey id { get; } + // display + public bool is_bts_type => display_name.StartsWith("BTS"); public string display_name { get; private set; } - public OrderMetadata meta => OrderDataHelper.get_metadata(order_type); - public virtual bool can_expand => !meta.NoProps; - public virtual bool is_expanded { - get => _is_expanded.Value; - set => _is_expanded.Value = value; - } + public OrderMetadata meta { get; } + // child algos public dynamic children_vm => _children_vm; public ObservableCollection child_algo_selectors => _child_algo_selectors; + // editing permissions + public AlgoEditingPermissions editing_permissions { get; private set; } public bool can_edit_values => EnumHelper.includes_flag(editing_permissions, AlgoEditingPermissions.AllowEditValues); public bool can_edit_structure => EnumHelper.includes_flag(editing_permissions, AlgoEditingPermissions.AllowEditStructure); public bool can_save_values => _can_save_values.Value; public bool can_save_structure => _can_save_structure.Value; + // misc + public virtual bool can_expand => !meta.NoProps; + public virtual bool is_expanded { get => _is_expanded.Value; set => _is_expanded.Value = value; } + // protected (observed props) protected OrdersModel model { get; private set; } protected SecurityMD? security_md { get; private set; } protected SecurityImmutable? security => security_md?.security; public void assign_to(AlgoDef value) { var algo = new TMutable(); - foreach (var (assign, load) in _auto_props) + foreach (var (name, assign, load) in _auto_props) assign(algo); _descriptor.Accessor.SetValue(value, algo); foreach (var sd in _child_algo_selector_data) { if (sd.selector.selected_algo != null) sd.set_order(value, sd.selector.selected_algo.created_assigned()); } - assign_to_internal(algo); } public void set_permissions(AlgoEditingPermissions editing_permissions) { @@ -217,26 +218,23 @@ namespace mbts.spark { public void load_from(AlgoDefi value) { if (value.CustomCase != order_type) return; - using (_def_change_notifier.defer_execution()) { - foreach (var sd in _child_algo_selector_data) { - var inner_def = sd.get_order(value); - if (inner_def.HasValue) { - if (security.HasValue) { - inner_def = OrderDataHelper.fit_to_type(inner_def.Value, security.Value.ContractCase); - if (!inner_def.HasValue) - continue; + var algom = _descriptor.Accessor.GetValue(value.CloneToMutable()) as TMutable ?? new TMutable(); + Disposable.replace(ref _pending_load, + new CompositeDisposable( + ObservableAutoWrapper.connect_item_actions(_child_algo_selector_data.AsCollection(), sd => { + var inner_def = sd.get_order(value); + if (inner_def.HasValue) { + if (security.HasValue) { + inner_def = OrderDataHelper.fit_to_type(inner_def.Value, security.Value.ContractCase); + if (!inner_def.HasValue) + return; + } + var vm = sd.selector.algos.GetOrAdd(OrderDataHelper.get_shallow_factory_key(inner_def.Value), k => create(k, inner_def.Value.display_name(), inner_def.Value.CustomCase)); + vm.load_from(inner_def.Value); + sd.selector.selected_algo = vm; } - var vm = sd.selector.algos.GetOrAdd(OrderDataHelper.get_shallow_factory_key(inner_def.Value), k => create(k, inner_def.Value.display_name(), inner_def.Value.CustomCase)); - vm.load_from(inner_def.Value); - sd.selector.selected_algo = vm; - } - } - var algom = _descriptor.Accessor.GetValue(value.CloneToMutable()) as TMutable ?? new TMutable(); - var algoi = _create_immutable(algom); - foreach (var (assign, load) in _auto_props) - load(algom); - load_from_internal(algoi); - } + }), + ObservableAutoWrapper.connect_item_actions(_auto_props.AsCollection(), p => p.load(algom)))); } public virtual async Task load_from_async(AlgoDefi defi) { @@ -254,92 +252,72 @@ namespace mbts.spark { } } var algom = _descriptor.Accessor.GetValue(defi.CloneToMutable()) as TMutable ?? new TMutable(); - var algoi = _create_immutable(algom); - foreach (var (assign, load) in _auto_props) + foreach (var (name, assign, load) in _auto_props) load(algom); - load_from_internal(algoi); return defi; } } protected virtual Task on_load_from_async(AlgoDefi defi) => Task.CompletedTask; - protected virtual void assign_to_internal(TMutable value) { } - protected virtual void load_from_internal(TImmutable value) { } - - protected void raise_definition_changed() => - _def_change_notifier.execute(); - - protected virtual void validate() { } protected virtual void on_permissions_changed() { foreach (var vm in child_algo_selectors.SelectMany(s => s.algos.AsCollection())) vm.set_permissions(editing_permissions); } + protected void raise_definition_changed() => + _def_change_notifier.execute(); + + protected virtual void validate() { } + protected override void Dispose(bool disposing) => Disposable.dispose(ref _resources); - #region Chidl Algo Selectors (add/remove/reset) - protected IAlgoSelector add_selector(string vm_prop_name, FieldDescriptor inner_desc) { - return add_selector(vm_prop_name, def => { - if (_descriptor.Accessor.GetValue(def.CloneToMutable()) is TMutable mval) { - if (inner_desc.Accessor.GetValue(mval) is AlgoDef inner_def) - return new AlgoDefi(inner_def); - } - return null; - }, (mdef, inner_def) => { - if (_descriptor.Accessor.GetValue(mdef) is TMutable mval) - inner_desc.Accessor.SetValue(mval, inner_def); - }); - } - - protected IAlgoSelector add_selector(string prop_name, Func get_order, Action set_order) => - add_selector(prop_name, get_order, set_order, (s, e) => validate()); - - protected IAlgoSelector add_selector(string prop_name, Func get_order, Action set_order, EventHandler on_errors_changed) { - var rv = new AlgoSelector(); - _child_algo_selector_data[prop_name] = new AlgoSelectorData(prop_name, rv, get_order, set_order); - return rv; - } - - protected IAlgoSelector add_selector(string prop_name, Func get_algo, Action set_algo) { - var rv = new AlgoSelector(); - _child_algo_selector_data[prop_name] = new AlgoSelectorData(prop_name, rv, def => _descriptor.Accessor.GetValue(def.CloneToMutable()) is TMutable mval ? get_algo(_create_immutable(mval)) : null, - (def, child_def) => { - if (_descriptor.Accessor.GetValue(def) is TMutable mval) - set_algo(mval, child_def); - }); - return rv; - } - - protected bool remove_selector(string prop_name) => - _child_algo_selector_data.Remove(prop_name); - - /// TODO: maybe should just be a protected field? - /// Conversely, it is nice to hide these sort of implementation-specific details from inheriting classes. - /// Fwiw, as of 2/12/2019, the only class that needs the ability to add/remove selectors dynamically is . - /// The other implementations simply add a whatever selectors they need in their constructor. - protected IDisposable reset_selectors() { - var to_remove = _child_algo_selector_data.Keys.ToList(); - _child_algo_selector_data.CollectionChanged += on_change; - void on_change(object sender, NotifyCollectionChangedEventArgs e) { - switch (e.Action) { - case NotifyCollectionChangedAction.Reset: - throw new InvalidOperationException($"{nameof(_child_algo_selector_data)} was reset; unable to continue processing incremental changes."); - default: - // catches Replace/Remove/Add ops (Add ops account for cases where the item was effectively replaced by a remove/re-add) - if (e.NewItems != null) { - foreach (AlgoSelectorData sd in e.NewItems) - to_remove.Remove(sd.prop_name); - } - break; + #region Child Algo Selectors + protected virtual IEnumerable get_selector_datum() => + OrderDataHelper.get_child_algo_data(order_type); + + protected void sync_selectors() { + using (reset()) { + foreach (var c in get_selector_datum()) { + _children_vm[c.name] = mk_selector(c.name, new Func(defi => { + var mchild = c.get_child(defi.CloneToMutable()); + if (mchild != null) + return new AlgoDefi(mchild); + return null; + }), + c.assign_child); } + _populate_selectors(); + } + // local methods + IDisposable reset() { + var to_remove = _child_algo_selector_data.Keys.ToList(); + _child_algo_selector_data.CollectionChanged += on_change; + void on_change(object sender, NotifyCollectionChangedEventArgs e) { + switch (e.Action) { + case NotifyCollectionChangedAction.Reset: + throw new InvalidOperationException($"{nameof(_child_algo_selector_data)} was reset; unable to continue processing incremental changes."); + default: + // catches Replace/Remove/Add ops (Add ops account for cases where the item was effectively replaced by a remove/re-add) + if (e.NewItems != null) { + foreach (AlgoSelectorData sd in e.NewItems) + to_remove.Remove(sd.prop_name); + } + break; + } + } + return Disposable.Create(() => { + _child_algo_selector_data.CollectionChanged -= on_change; + foreach (var id in to_remove) + _child_algo_selector_data.Remove(id); + }); + } + IAlgoSelector mk_selector(string prop_name, Func get_order, Action set_order) { + var rv = new AlgoSelector(); + _child_algo_selector_data[prop_name] = new AlgoSelectorData(prop_name, rv, get_order, set_order); + return rv; } - return Disposable.Create(() => { - _child_algo_selector_data.CollectionChanged -= on_change; - foreach (var id in to_remove) - _child_algo_selector_data.Remove(id); - }); } #endregion @@ -347,7 +325,7 @@ namespace mbts.spark { protected Property add_property(string prop_name, int target_field_number, T init_value = default) { var prop = backing(prop_name, init_value); var field_desc = new TMutable().Descriptor.FindFieldByNumber(target_field_number); - _auto_props.Add((mval => { + _auto_props.Add((prop_name, mval => { if (mval != null) field_desc.Accessor.SetValue(mval, prop.Value); }, mval => { @@ -356,22 +334,12 @@ namespace mbts.spark { return prop; } - protected UserProperty add_user_property(string prop_name, int target_field_number, T init_value = default) { - var prop = user_backing(prop_name, init_value); - var field_desc = new TMutable().Descriptor.FindFieldByNumber(target_field_number); - add_property( - mdef => ConvertUtils.try_convert(field_desc.Accessor.GetValue(mdef)), - (mdef, val) => field_desc.Accessor.SetValue(mdef, val), - val => prop.bypass_setter(val), - () => prop.Value); - return prop; - } - protected Property add_property(string prop_name, int target_field_number, TImmutableValue init_value = default) where TMutableValue : class, IMessage, new() where TImmutableValue : IImmutableMessage { var prop = backing(prop_name, init_value); var field_desc = new TMutable().Descriptor.FindFieldByNumber(target_field_number); var immutable_factory = OrderTypeVMUtils.immutable_factory(); add_property( + prop_name, mdef => field_desc.Accessor.GetValue(mdef) as TMutableValue, (mdef, mval) => field_desc.Accessor.SetValue(mdef, mval), mval => prop.set(immutable_factory(mval ?? new TMutableValue())), @@ -383,15 +351,36 @@ namespace mbts.spark { return prop; } - protected void add_property(Func get_from_def, Action assign_to_def, Action set_local, Func get_local) => - _auto_props.Add((def => { + protected void add_property(string prop_name, Func get_from_def, Action assign_to_def, Action set_local, Func get_local) => + _auto_props.Add(( + prop_name, + def => { assign_to_def(def, get_local()); }, def => { set_local(get_from_def(def)); })); - protected virtual void on_model_internal(OrdersModel model) { } - protected virtual void on_security_md_internal(SecurityMD? security_md) { } + protected void add_property(string prop_name, Action assign, Action load) => + _auto_props[prop_name] = (prop_name, assign, load); + + protected UserProperty add_user_property(string prop_name, int target_field_number, T init_value = default) { + var prop = user_backing(prop_name, init_value); + var field_desc = new TMutable().Descriptor.FindFieldByNumber(target_field_number); + add_property( + prop_name, + mdef => ConvertUtils.try_convert(field_desc.Accessor.GetValue(mdef)), + (mdef, val) => field_desc.Accessor.SetValue(mdef, val), + val => prop.bypass_setter(val), + () => prop.Value); + return prop; + } + + protected void remove_property(string prop_name) => + _auto_props.Remove(prop_name); + #endregion + + protected virtual void on_model_internal() { } + protected virtual void on_security_md_internal() { } // model void IObserver.OnNext(OrdersModel model) { @@ -402,36 +391,39 @@ namespace mbts.spark { return; } this.model = model; - on_model_internal(model); - _reset(); + using (_def_change_notifier.defer_execution()) { + on_model_internal(); + sync_selectors(); + } } void IObserver.OnError(Exception error) { } void IObserver.OnCompleted() { } // security md void IObserver.OnNext(SecurityMD? security_md) { this.security_md = security_md; - on_security_md_internal(security_md); - _reset(); + using (_def_change_notifier.defer_execution()) { + on_security_md_internal(); + _populate_selectors(); + } } void IObserver.OnError(Exception error) { } void IObserver.OnCompleted() { } - IDisposable _hook; - void _reset() { + IDisposable _selector_data_hooks; + void _populate_selectors() { if (model != null && security.HasValue) { var algo_data = model.factory.default_algos(security.Value); var default_algo = new AlgoKey(OrderDataHelper.get_default_algo(OrderDataHelper.get_algo_format(security.Value.ContractCase))); foreach (var sd in _child_algo_selectors) sd.load_algo_data_recursive(algo_data, default_algo); - Disposable.replace(ref _hook, ObservableAutoWrapper.connect_item_hooks(child_algo_selectors, s => { - s.load_algo_data_recursive(algo_data, default_algo); - return Disposable.empty; - })); + Disposable.replace( + ref _selector_data_hooks, + ObservableAutoWrapper.connect_item_hooks(child_algo_selectors, s => { + s.load_algo_data_recursive(algo_data, default_algo); + return Disposable.empty; + })); } } - - public IDisposable Subscribe(IObserver observer) => throw new NotImplementedException(); - #endregion } struct AlgoSelectorData { @@ -521,4 +513,4 @@ namespace mbts.spark { } #endregion } -} +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs index 194aa952b..ad61e47cc 100644 --- a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs @@ -23,7 +23,38 @@ namespace mbts.spark { _template = backing(nameof(template)); /// depends on (i.e. initialize the latter first). _strategy_editor_wrapper = new StrategyEditorWrapper(this); - concat_disposable(_strategy_editor_wrapper, _template.Subscribe(vals => validate())); + _resources.AddRange(_strategy_editor_wrapper, _template.Subscribe(vals => validate())); + // strategy + add_property( + nameof(SpreaderDef.ExecutionStrategy), + mdef => mdef.ExecutionStrategy, + (mdef, val) => mdef.ExecutionStrategy = val, + val => { + if (template.HasValue) { + template = template.Value.with(execution_strategy: val); + } else { + var mdef = new SpreaderDef { + Security = security?.CloneToMutable(), + ExecutionStrategy = val + }; + template = new SpreaderDefi(mdef); + } + }, + () => strategy_editor?.get_strategy().CloneToMutable()); + // security + add_property( + nameof(SpreaderDef.Security), + mdef => mdef.Security, + (mdef, val) => mdef.Security = val, + val => { + if (template.HasValue) { + template = template.Value.with(security: val); + } else { + var mdef = new SpreaderDef { Security = val }; + template = new SpreaderDefi(mdef); + } + }, + () => security?.CloneToMutable()); validate(); } @@ -43,12 +74,6 @@ namespace mbts.spark { } public bool is_loaded { get; private set; } - protected override void assign_to_internal(SpreaderDef value) => - value.MergeFrom(template.HasValue ? template.Value.CloneToMutable() : new SpreaderDef()); - - protected override void load_from_internal(SpreaderDefi value) => - _template.set(value); - protected override void validate() { base.validate(); if (!template.HasValue) diff --git a/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs index 63378127d..854628a38 100644 --- a/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs @@ -31,11 +31,6 @@ namespace mbts.spark { public ContractSpecificationImmutable? spec => _security_md.spec_or_default(); - protected override void load_from_internal(StopLimitDefi value) { - // TODO: the StopLimitOrderDefinition, StopLimitOrderDefinitionImmutable needs relative vs absolute prices to function as a useful template (talk to Pedro) - _stop_price.bypass_setter(value.StopPrice); - } - // no need to constantly poll the md, just check the inline props when the popup opens, and right before sending an order // (if the user never looks at the popup, assume that the bid_price will be used) // TODO: add settings so the trigger-price can default to something relative to the md, e.g "bid-price" or "ask-price - nticks" or "best-bid-price with a minimum size of 10" diff --git a/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs index f12b3e9c9..3b4cbb713 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs @@ -16,14 +16,26 @@ namespace mbts.spark { public TimeBoxOrderVM(AlgoKey key, string display_name, AlgoEditingPermissions editing_permissions) : base(key, display_name, editing_permissions) { - add_property(def => def.Start, (def, val) => def.Start = val, val => absolute_start = TimeTextTuple.FromDateTime(val.ToDateTime()), () => { - _validate(out DateTime? start_time, out DateTime? _); - return start_time.GetValueOrDefault().ToUniversalTime().ToGoogleTime(); - }); - add_property(def => def.Stop, (def, val) => def.Stop = val, val => absolute_stop = TimeTextTuple.FromDateTime(val.ToDateTime()), () => { - _validate(out DateTime? _, out DateTime? stop_time); - return stop_time.GetValueOrDefault().ToUniversalTime().ToGoogleTime(); - }); + // start + add_property( + nameof(TimeBoxOrderDefinition.Start), + def => def.Start, + (def, val) => def.Start = val, + val => absolute_start = TimeTextTuple.FromDateTime(val.ToDateTime()), + () => { + _validate(out DateTime? start_time, out DateTime? _); + return start_time.GetValueOrDefault().ToUniversalTime().ToGoogleTime(); + }); + // stop + add_property( + nameof(TimeBoxOrderDefinition.Stop), + def => def.Stop, + (def, val) => def.Stop = val, + val => absolute_stop = TimeTextTuple.FromDateTime(val.ToDateTime()), + () => { + _validate(out DateTime? _, out DateTime? stop_time); + return stop_time.GetValueOrDefault().ToUniversalTime().ToGoogleTime(); + }); validate(); } diff --git a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs index f1cff6c37..28758748b 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -31,13 +31,64 @@ namespace mbts.spark { _is_priceout_checked = create_user_prop(nameof(is_priceout_checked), false); _is_timeout_checked = create_user_prop(nameof(is_timeout_checked), false); _timeout_secs = create_user_prop(nameof(timeout_secs), 10); + add_property(nameof(TriggerDef), assign, load); validate(); - // + // local methods UserProperty create_user_prop(string name, T default_value = default) { var rv = user_backing(name, default_value); rv.Changed += validation_callback; return rv; } + void assign(TriggerDef trigger_def) { + trigger_def.TriggerAction = new TriggerAction(); + if (security.HasValue) + trigger_def.TriggerAction.SecurityId = security.Value.Id; + trigger_def.TriggerCondition = new TriggerCondition() { + PriceType = trigger_price_type, + AbsolutePriceTrigger = new AbsolutePriceTrigger() { TriggerQuantity = new TriggerQuantity() }, + }; + trigger_def.ExitCondition = new TriggerExitCondition { + ConditionalCancel = is_priceout_checked, + TimeoutEnabled = is_timeout_checked, + TimeoutSeconds = (uint)(timeout_secs) + }; + switch (order_price_case) { + case OrderpriceOneofCase.Price: + // should already be null, setting it here for clarity + trigger_def.TriggerAction.Payup = null; + trigger_def.TriggerAction.Price = fixed_price; + break; + case OrderpriceOneofCase.Payup: + trigger_def.TriggerAction.Price = double.NaN; + trigger_def.TriggerAction.Payup = new TriggerPayupPrice { + PayupTicks = payup_ticks, + PayupPriceType = payup_price_type + }; + break; + } + } + void load(TriggerDef trigger_defi) { + if (trigger_defi.TriggerCondition is TriggerCondition c) { + trigger_price_type = c.PriceType; + } + if (trigger_defi.ExitCondition is TriggerExitCondition ec) { + is_priceout_checked = ec.ConditionalCancel; + is_timeout_checked = ec.TimeoutEnabled; + if (ec.TimeoutSeconds < int.MaxValue) + timeout_secs = (int)ec.TimeoutSeconds; + } + if (trigger_defi.TriggerAction is TriggerAction a) { + if (a.Payup is TriggerPayupPrice pp) { + order_price_case = OrderpriceOneofCase.Payup; + fixed_price = double.NaN; + payup_ticks = pp.PayupTicks; + payup_price_type = pp.PayupPriceType; + } else { + order_price_case = OrderpriceOneofCase.Price; + fixed_price = a.Price; + } + } + } void validation_callback(T oldval, T newval) => validate(); } @@ -56,68 +107,20 @@ namespace mbts.spark { public bool is_timeout_checked { get => _is_timeout_checked.Value; set => _is_timeout_checked.Value = value; } public int timeout_secs { get => _timeout_secs.Value; set => _timeout_secs.Value = value; } - protected override void assign_to_internal(TriggerDef trigger_def) { - trigger_def.TriggerAction = new TriggerAction(); - if (security.HasValue) - trigger_def.TriggerAction.SecurityId = security.Value.Id; - trigger_def.TriggerCondition = new TriggerCondition() { - PriceType = trigger_price_type, - AbsolutePriceTrigger = new AbsolutePriceTrigger() { TriggerQuantity = new TriggerQuantity() }, - }; - trigger_def.ExitCondition = new TriggerExitCondition { - ConditionalCancel = is_priceout_checked, - TimeoutEnabled = is_timeout_checked, - TimeoutSeconds = (uint)(timeout_secs) - }; - switch (order_price_case) { - case OrderpriceOneofCase.Price: - // should already be null, setting it here for clarity - trigger_def.TriggerAction.Payup = null; - trigger_def.TriggerAction.Price = fixed_price; - break; - case OrderpriceOneofCase.Payup: - trigger_def.TriggerAction.Price = double.NaN; - trigger_def.TriggerAction.Payup = new TriggerPayupPrice { - PayupTicks = payup_ticks, - PayupPriceType = payup_price_type - }; - break; - } - } - - protected override void load_from_internal(TriggerDefi trigger_defi) { - if (trigger_defi.HasTriggerCondition) { - trigger_price_type = trigger_defi.TriggerCondition.PriceType; - } - if (trigger_defi.HasExitCondition) { - var exit_condition = trigger_defi.ExitCondition; - is_priceout_checked = exit_condition.ConditionalCancel; - is_timeout_checked = exit_condition.TimeoutEnabled; - if (exit_condition.TimeoutSeconds < int.MaxValue) - timeout_secs = (int)exit_condition.TimeoutSeconds; - } - if (trigger_defi.HasTriggerAction) { - var trigger_action = trigger_defi.TriggerAction; - if (trigger_action.HasPayup) { - order_price_case = OrderpriceOneofCase.Payup; - fixed_price = double.NaN; - var payup = trigger_action.Payup; - payup_ticks = payup.PayupTicks; - payup_price_type = payup.PayupPriceType; - } else { - order_price_case = OrderpriceOneofCase.Price; - fixed_price = trigger_action.Price; - } - } - } - - void _refresh_md() { + protected override void on_security_md_internal() { if (security.HasValue) { security_md.Value.md.get_bbo(ref _bbo_ref, out co2.NativePriceSize bid, out co2.NativePriceSize ask); _best_bid = bid.price; _best_ask = ask.price; security_md.Value.md.get_last_trade(ref _last_trade_ref, out co2.NativePriceSize ps, out DateTime ts, out ulong v); } + if (double.IsNaN(fixed_price) || !_fixed_price.setter_called) { + switch (trigger_price_type) { + case TriggerPriceType.Bid: _fixed_price.bypass_setter(_best_bid); break; + case TriggerPriceType.Ask: _fixed_price.bypass_setter(_best_ask); break; + case TriggerPriceType.LastTradePrice: _fixed_price.bypass_setter(_last_trade_price); break; + } + } } protected override void validate() { @@ -131,17 +134,6 @@ namespace mbts.spark { } assert(!is_timeout_checked || timeout_secs > 0, nameof(timeout_secs), "Please specify valid Timeout(secs)."); } - - protected override void on_security_md_internal(SecurityMD? security_md) { - _refresh_md(); - if (double.IsNaN(fixed_price) || !_fixed_price.setter_called) { - switch (trigger_price_type) { - case TriggerPriceType.Bid: _fixed_price.bypass_setter(_best_bid); break; - case TriggerPriceType.Ask: _fixed_price.bypass_setter(_best_ask); break; - case TriggerPriceType.LastTradePrice: _fixed_price.bypass_setter(_last_trade_price); break; - } - } - } } } } \ No newline at end of file diff --git a/src/client/spark/core/Collections/ObservableAutoWrapper.cs b/src/client/spark/core/Collections/ObservableAutoWrapper.cs index 3836876d8..c77928d4d 100644 --- a/src/client/spark/core/Collections/ObservableAutoWrapper.cs +++ b/src/client/spark/core/Collections/ObservableAutoWrapper.cs @@ -1,4 +1,3 @@ -using bts.collections; using bts.utils; using mbts.utils; using NUnit.Framework; @@ -11,11 +10,6 @@ using System.Linq; using System.Reactive.Disposables; namespace mbts.ui.utility { - /// - /// The sole purpose of this class is to offer a less verbose alternative to - /// "new ObservableAutoWrapper(doodi, poodi)" - /// when the generic types are implicit - /// static class ObservableAutoWrapper { public static ObservableAutoWrapper Create(ObservableCollection models, Func converter) { return new ObservableAutoWrapper(models, converter); @@ -198,6 +192,12 @@ namespace mbts.ui.utility { } } + public static IDisposable connect_item_actions(IReadOnlyObservableCollection source, Action action) => + source.Subscribe((s, e) => CollectionHelper.process_new_items(source, action, e)); + + public static IDisposable connect_item_actions(ObservableCollection source, Action action) => + source.Subscribe((s, e) => CollectionHelper.process_new_items(source, action, e)); + public static IDisposable connect_item_hooks(IReadOnlyObservableCollection source, Func get_item_hook) { var item_hooks = source.Select(get_item_hook).ToList(); return new CompositeDisposable( diff --git a/src/client/spark/core/Utility/CollectionHelper.cs b/src/client/spark/core/Utility/CollectionHelper.cs index d74e91393..65d7252bf 100644 --- a/src/client/spark/core/Utility/CollectionHelper.cs +++ b/src/client/spark/core/Utility/CollectionHelper.cs @@ -75,6 +75,20 @@ namespace mbts.utils { } } + public static void process_new_items(IEnumerable source, Action on_new_item, NotifyCollectionChangedEventArgs e) { + switch (e.Action) { + case NotifyCollectionChangedAction.Add: + case NotifyCollectionChangedAction.Replace: + foreach (T v in e.NewItems) + on_new_item(v); + break; + case NotifyCollectionChangedAction.Reset: + foreach (T v in source) + on_new_item(v); + break; + } + } + // Note: this is not optimized, be wary of use with large collections public static void sync_with_never_duplicate(ObservableCollection dest, IEnumerable src) => sync_with_never_duplicate(dest, src, EqualityComparer.Default); diff --git a/src/client/spark/core/Utility/ProtoHelper.cs b/src/client/spark/core/Utility/ProtoHelper.cs new file mode 100644 index 000000000..987c6d041 --- /dev/null +++ b/src/client/spark/core/Utility/ProtoHelper.cs @@ -0,0 +1,91 @@ +using mbts; +using Google.Protobuf; +using Google.Protobuf.Reflection; +using mbts.ui.utility; +using System; +using System.Collections.Generic; +using System.Linq; +using mbts.utils; + +namespace bts.utils { + static class ProtoHelper { + const string + _case_suffix = "Case", + _oneof_case_suffix = "OneofCase"; + + public static MessageDescriptor Descriptor() where T : IMessage, new() => + _DescriptorImpl.value; + + public static OneofDescriptor get_oneof_descriptor(string prop_name) where T : IMessage, new() { + prop_name = prop_name.iremove_suffix(_case_suffix); + return Descriptor().Oneofs.FirstOrDefault(d => d.Name.iequals(prop_name)); + } + + public static IReadOnlyDictionary get_oneof_descriptor_index(string prop_name) + where T : IMessage, new() + where TOneofCase : struct => + _DescriptorImpl.OneofImpl.get_descriptor_case_index(prop_name); + + public static FieldDescriptor get_oneof_field_descriptor(TOneofCase oneof_case) where T : IMessage, new() where TOneofCase : struct { + string oneof_name = oneof_case.ToString(); + return Descriptor().Fields.InFieldNumberOrder().FirstOrDefault(fd => fd.Name.Replace("_", "").iequals(oneof_name)); + } + + public static Type get_field_type(FieldDescriptor field_descriptor) { + switch (field_descriptor.FieldType) { + case FieldType.Bool: return typeof(bool); + case FieldType.Bytes: return typeof(ByteString); + case FieldType.Double: return typeof(double); + case FieldType.Float: return typeof(float); + case FieldType.UInt32: return typeof(uint); + case FieldType.UInt64: return typeof(ulong); + // int + case FieldType.SFixed32: + case FieldType.Fixed32: + case FieldType.SInt32: + case FieldType.Int32: return typeof(int); + // long + case FieldType.SFixed64: + case FieldType.Fixed64: + case FieldType.SInt64: + case FieldType.Int64: return typeof(long); + // + case FieldType.String: return typeof(string); + case FieldType.Enum: return field_descriptor.EnumType.ClrType; + case FieldType.Message: return field_descriptor.MessageType.ClrType; + default: throw ExceptionBuilder.Argument.unexpected_case(field_descriptor.FieldType, nameof(field_descriptor)); + } + } + + public static IReadOnlyDictionary get_oneof_descriptor_index(OneofDescriptor descriptor) where TOneofCase : struct => + descriptor.Fields.ToDictionary(fd => EnumHelper.parse(fd.Name.Replace("_", ""))); + + static class _DescriptorImpl where T : IMessage, new() { + public static readonly MessageDescriptor value = new T().Descriptor; + + public static class OneofImpl where TOneofCase : struct { + static Dictionary> _descriptor_case_indices = + new Dictionary>(); + + public static IReadOnlyDictionary get_descriptor_case_index(string prop_name) { + /// Use local copy because is updated atomically. + var dci = _descriptor_case_indices; + if (!dci.TryGetValue(prop_name, out IReadOnlyDictionary rv)) { + /// Update atomically (lock-free). + /// 1) clone the local copy. + /// 2) add the new KeyValue to the clone. + /// 3) assign the clone back to . + rv = get_oneof_descriptor_index(get_oneof_descriptor(prop_name)) + .ToDictionary(kv => kv.Key, kv => (kv.Value, get_field_type(kv.Value))); + dci = dci.ToDictionary(); + dci.Add(prop_name, rv); + /// It is possible for add ops to be overwritten. + /// This is perfectly safe, just means that the 'clone-add-assign' will be repeated the next time a caller requests this key. + _descriptor_case_indices = dci; + } + return rv; + } + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/view/Spark/Core/OrderUtils.cs b/src/client/spark/view/Spark/Core/OrderUtils.cs index 15ba5770c..8324e92e7 100644 --- a/src/client/spark/view/Spark/Core/OrderUtils.cs +++ b/src/client/spark/view/Spark/Core/OrderUtils.cs @@ -213,7 +213,7 @@ namespace mbts.spark { // local methods void impl(StringBuilder sb, CustomOrderDefinition mdef) { sb.Append(abbreviate(mdef.CustomCase)); - foreach (var cad in OrderDataHelper.get_child_algo_data(def.CustomCase)) { + foreach (var cad in OrderDataHelper.get_child_algo_data(def.CloneToMutable())) { var child = cad.get_child(mdef); sb.Append(".["); impl(sb, child); diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index 64ab2b744..9670f4048 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -17,12 +17,27 @@ using System.Reactive.Linq; using OrderState = bts.api.orderman.OrderState; namespace mbts.spark.utilities { + struct ChildAlgoData { + public readonly string name; + public readonly Func get_child_from_impl; + public readonly Action assign_child_to_impl; + public readonly Func get_child; + public readonly Action assign_child; + + public ChildAlgoData(string name, Func get_child_from_impl, Action assign_child_to_impl, Func get_child, Action assign_child) { + this.name = name; + this.get_child = get_child; + this.assign_child = assign_child; + this.get_child_from_impl = get_child_from_impl; + this.assign_child_to_impl = assign_child_to_impl; + } + } + // at some point, user-default settings for orders can be managed here // OrdersModel imports and exposes OrderFactory as a public property [Export(typeof(OrderFactory))] class OrderFactory : IDisposable { - static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.spreader_order }; - + static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.default_order }; readonly AdminModel _admin_model; readonly DynamicOrderHelper _dynamic_helper; IDisposable _dispose; @@ -250,20 +265,6 @@ namespace mbts.spark.utilities { } } - public struct ChildAlgoData { - public readonly Func get_child; - public readonly Action set_child; - public readonly string name; - public readonly FieldDescriptor descriptor; - - public ChildAlgoData(string name, FieldDescriptor descriptor, Func get_child, Action set_child) { - this.name = name; - this.get_child = get_child; - this.set_child = set_child; - this.descriptor = descriptor; - } - } - // algo-type-case maps // Note: obv this will break if we change the name of the 'CustomOneofCase' field static readonly OneofDescriptor _oneof_desc = CustomOrderDefinition.Descriptor.Oneofs.FirstOrDefault(fd => fd.Name == "custom"); @@ -283,12 +284,17 @@ namespace mbts.spark.utilities { var value_descriptors = new List(0); foreach (var f in fd.MessageType.Fields.InDeclarationOrder()) { if (is_child_algo_field(f)) { - child_algo_data.Add(new ChildAlgoData(f.Name, f, + child_algo_data.Add(new ChildAlgoData(f.Name, + msg => f.Accessor.GetValue(msg) as CustomOrderDefinition, + (msg, child) => f.Accessor.SetValue(msg, child), def => { var type_def = fd.Accessor.GetValue(def) as IMessage; return f.Accessor.GetValue(type_def) as CustomOrderDefinition; }, - (def, child) => f.Accessor.SetValue(def, child))); + (def, child) => { + if (fd.Accessor.GetValue(def) is IMessage m) + f.Accessor.SetValue(m, child); + })); } else { value_descriptors.Add(f); } @@ -302,6 +308,30 @@ namespace mbts.spark.utilities { f.FieldType == FieldType.Message && f.MessageType.ClrType == typeof(CustomOrderDefinition); } + public static IReadOnlyList get_child_algo_data(CustomOrderDefinitionImmutable defi) => + get_child_algo_data(defi.CloneToMutable()); + + public static IReadOnlyList get_child_algo_data(CustomOrderDefinition algo) { + switch (algo.CustomCase) { + case CustomOrderDefinition.CustomOneofCase.Dynamic: + return algo.Dynamic.OrderParams.Where(kv => kv.Value.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef).Select(kv => new ChildAlgoData(kv.Key, def => { + var p = ((DynamicOrderDefinition)def).OrderParams[kv.Key]; + if (p.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef) + return p.AsOrderDef; + return null; + }, + (msg, child) => { + if (msg is DynamicOrderDefinition dyn) + dyn.OrderParams.GetOrAdd(kv.Key, k => new DynamicOrderParam()).AsOrderDef = child; + }, + def => def.Dynamic.OrderParams.TryGetValue(kv.Key, out DynamicOrderParam param) && param.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef ? param.AsOrderDef : null, + (def, child) => def.Dynamic.OrderParams.GetOrAdd(kv.Key, k => new DynamicOrderParam()).AsOrderDef = child)) + .ToList(); + default: + return get_child_algo_data(algo.CustomCase); + } + } + public static IReadOnlyList get_child_algo_data(CustomOrderDefinition.CustomOneofCase algo_type) => _algo_type_case_descriptor_data.TryGetValue(algo_type, out AlgoTypeCaseDescriptorData d) ? d.child_algo_data : Array.Empty(); @@ -366,7 +396,7 @@ namespace mbts.spark.utilities { // hide mutable-def implementation IEnumerable impl(CustomOrderDefinition mdef) { yield return mdef.CustomCase; - foreach (var sd in get_child_algo_data(mdef.CustomCase)) { + foreach (var sd in get_child_algo_data(mdef)) { var child = sd.get_child(mdef); if (child != null) { yield return child.CustomCase; @@ -412,7 +442,7 @@ namespace mbts.spark.utilities { if (child == null) return null; var type_def = (IMessage)desc_data.type_case_descriptor.Accessor.GetValue(def); - cad.descriptor.Accessor.SetValue(type_def, child); + cad.assign_child_to_impl(type_def, child); } break; } @@ -429,13 +459,11 @@ namespace mbts.spark.utilities { def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() }; break; default: - var desc_data = _algo_type_case_descriptor_data[def.CustomCase]; - foreach (var cad in desc_data.child_algo_data) { + foreach (var cad in get_child_algo_data(def)) { var child = outright_impl(cad.get_child(def)); if (child == null) return null; - var type_def = (IMessage)desc_data.type_case_descriptor.Accessor.GetValue(def); - cad.descriptor.Accessor.SetValue(type_def, child); + cad.assign_child(def, child); } break; } @@ -501,8 +529,8 @@ namespace mbts.spark.utilities { fd.Accessor.SetValue(tgt_type_def, fd.Accessor.GetValue(src_type_def)); } foreach (var cad in desc_data.child_algo_data) { - var src_child = cad.descriptor.Accessor.GetValue(src_type_def) as CustomOrderDefinition; - var tgt_child = cad.descriptor.Accessor.GetValue(tgt_type_def) as CustomOrderDefinition; + var src_child = cad.get_child_from_impl(src_type_def); + var tgt_child = cad.get_child_from_impl(tgt_type_def); copy_values(src_child, ref tgt_child); } } @@ -558,7 +586,7 @@ namespace mbts.spark.utilities { public static bool structure_equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) { return impl(a.CloneToMutable(), b.CloneToMutable()); bool impl(CustomOrderDefinition ma, CustomOrderDefinition mb) => - a.CustomCase == b.CustomCase && get_child_algo_data(a.CustomCase).All(cad => impl(cad.get_child(ma), cad.get_child(mb))); + ma.CustomCase == mb.CustomCase && get_child_algo_data(ma).All(cad => impl(cad.get_child(ma), cad.get_child(mb))); } public static bool iceberg_equals(IcebergOrderDefinitionImmutable a, IcebergOrderDefinitionImmutable b) => @@ -895,4 +923,4 @@ namespace mbts.spark.utilities { public static SpreaderOrderDefinition SpreaderOrderDefinition() => new SpreaderOrderDefinition { ExecutionStrategy = new ExecutionStrategy() }; } } -} \ No newline at end of file +} diff --git a/src/client/spark_core/utils/GlobalExtensions.cs b/src/client/spark_core/utils/GlobalExtensions.cs index ee6769ee7..ee291796b 100644 --- a/src/client/spark_core/utils/GlobalExtensions.cs +++ b/src/client/spark_core/utils/GlobalExtensions.cs @@ -19,6 +19,12 @@ namespace mbts { public static bool iequals(this string str, string comparand) => string.Equals(str, comparand, StringComparison.CurrentCultureIgnoreCase); + public static string iremove_suffix(this string str, string suffix) { + if (str.EndsWith(suffix, StringComparison.CurrentCultureIgnoreCase)) + str = str.Remove(str.Length - suffix.Length); + return str; + } + public static T choose(this Random r, IEnumerable range) { var index = r.Next(0, range.Count()); return range.Skip(index).First();