pushing for join to look at joinordervm validation

This commit is contained in:
Kevin Darby committed 2018-05-25 18:04:58 -04:00
1 parent 1e54cb1daf
commit 7a8a38f89d
23 files changed
+1444 -121

No files matched your search

@@ -21,8 +21,9 @@ namespace mbts.ui.spark {
public DataTemplate StopMarketOrderTemplate { get; set; }
public DataTemplate TimeBoxOrderTemplate { get; set; }
public DataTemplate TickOrderTemplate { get; set; }
public DataTemplate LeanOrderTemplate { get; set; }
public DataTemplate JoinOrderTemplate { get; set; }
public DataTemplate LeaderOrderTemplate { get; set; }
public DataTemplate TopOrderTemplate { get; set; }
public DataTemplate IcebergOrderTemplate { get; set; }
public DataTemplate SpreaderTemplate { get; set; }
public DataTemplate BTSStopOrderTemplate { get; set; }
@@ -37,8 +38,9 @@ namespace mbts.ui.spark {
case CustomOrderDefinition.CustomOneofCase.StopLimit: return StopLimitOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.TimeBox: return TimeBoxOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Tick: return TickOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Lean: return LeanOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Leader: return LeaderOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Top: return TopOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate;
case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate;
}
@@ -0,0 +1,284 @@
using bts.api;
using bts.api.orderman;
using mbts.ui;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark
{
static partial class OrderTypeVMFactory
{
class InlineJoinOrderProperties
{
public InlineJoinOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types)
{
ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
var hedgetype = CustomOneofCase.Lean;
ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types");
this.selected_hedge_order_type = new InlineUserProperty<CustomOneofCase>(hedgetype, true);
this.hedge_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
min_tick_offset_on_deploy = new InlineUserProperty<uint>(0, false);
join_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
new bts.spark.QuantityMeasure() { Absolute = 1}, false);
enable_hedge = new InlineUserProperty<bool>(false, false);
hedge_ticks = new InlineUserProperty<int>(1, false);
}
public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
public readonly InlineUserProperty<CustomOneofCase> selected_hedge_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> hedge_order_types;
public readonly InlineUserProperty<uint> min_tick_offset_on_deploy;
public readonly InlineUserProperty<bts.spark.QuantityMeasure> join_threshold;
public readonly InlineUserProperty<bool> enable_hedge;
public readonly InlineUserProperty<int> hedge_ticks;
}
class JoinOrderVM : OrderTypeVMBase<JoinOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable
{
readonly IObservable<SecurityImmutable> _security_source;
SecurityImmutable? _security;
ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
InlineJoinOrderProperties _inline_props;
IOrderTypeVM _child_order;
IDisposable _dispose, _child_order_errors_sub;
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _hedge_order_choices;
IOrderTypeVM _hedge_order;
IDisposable _hedge_order_errors_sub;
public uint min_tick_offset_on_deploy { get; set; } = 0;
public bts.spark.QuantityMeasure join_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
bool _enable_hedge = false;
public bool enable_hedge
{
get { return _enable_hedge; }
set
{
_enable_hedge = value;
RaisePropertyChanged(nameof(enable_hedge));
}
}
public int hedge_ticks { get; set; } = 1;
public JoinOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
: this(model, security_source, security_source.Select(s =>
new InlineJoinOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
public JoinOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
IObservable<InlineJoinOrderProperties> inline_properties) : base(model)
{
_security_source = security_source;
_dispose = Disposable.Create(
security_source.ObserveOnDispatcher()
.Subscribe(s => _security = s),
inline_properties.ObserveOnDispatcher()
.Subscribe(p => {
if (_order_types.Count == 0 || p.child_order_types.force_override)
{
_order_types.SetItems(p.child_order_types.value);
}
if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override))
{
_select_child_order(p.selected_child_order_type.value);
}
if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override))
{
_select_hedge_order(p.selected_hedge_order_type.value);
}
if (p.min_tick_offset_on_deploy.force_override)
{
min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value;
RaisePropertyChanged(nameof(min_tick_offset_on_deploy));
}
if (p.join_threshold.force_override)
{
join_threshold = p.join_threshold.value;
RaisePropertyChanged(nameof(join_threshold));
}
if (p.enable_hedge.force_override)
{
enable_hedge = p.enable_hedge.value;
RaisePropertyChanged(nameof(enable_hedge));
}
if (p.hedge_ticks.force_override)
{
hedge_ticks = p.hedge_ticks.value;
RaisePropertyChanged(nameof(hedge_ticks));
}
_inline_props = p;
_validate();
})
);
_validate();
}
public override void assign_to(CustomOrderDefinition value)
{
if (_child_order == null)
_select_child_order(model.factory.default_order_type(_security.Value, true));
if (_hedge_order == null && enable_hedge)
_select_hedge_order(model.factory.default_order_type(_security.Value, true));
_validate();
if (!HasErrors)
{
var i = factory.join_order();
i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy;
i.JoinThreshold = join_threshold;
i.EnableHedge = enable_hedge;
i.HedgeTicks = hedge_ticks;
child_order.assign_to(i.Child);
if(enable_hedge && hedge_order != null)
hedge_order.assign_to(i.Hedge);
value.Join = i;
}
}
public ICollection<IOrderTypeVM> child_order_types
{
get
{
if (_child_order_choices == null)
_child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
return _child_order_choices;
}
}
public ICollection<IOrderTypeVM> hedge_order_types
{
get
{
if (_hedge_order_choices == null)
_hedge_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
return _hedge_order_choices;
}
}
public IOrderTypeVM child_order
{
get
{
init();
return _child_order;
}
set
{
Disposable.dispose(ref _child_order_errors_sub);
_child_order = value;
_child_order?.init();
if (_child_order is INotifyDataErrorInfo ndei)
{
ndei.ErrorsChanged += on_errors_changed;
void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
_validate();
_child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
}
_validate();
RaisePropertyChanged(nameof(child_order));
}
}
public IOrderTypeVM hedge_order
{
get
{
init();
return _hedge_order;
}
set
{
Disposable.dispose(ref _hedge_order_errors_sub);
_hedge_order = value;
_hedge_order?.init();
if (_hedge_order is INotifyDataErrorInfo ndei)
{
ndei.ErrorsChanged += on_errors_changed;
void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
_validate();
_hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
}
_validate();
RaisePropertyChanged(nameof(hedge_order));
}
}
public void Dispose()
{
Disposable.dispose(ref _dispose);
if (_child_order_choices != null)
_child_order_choices.OfType<IDisposable>().DisposeAll();
if (_hedge_order_choices != null)
_hedge_order_choices.OfType<IDisposable>().DisposeAll();
}
public override void init()
{
if (_child_order == null && _security.HasValue)
_select_child_order();
if (_hedge_order == null && _security.HasValue && enable_hedge)
_select_hedge_order();
_validate();
}
void _select_child_order()
{
CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
_inline_props.selected_child_order_type.value :
model.factory.default_order_type(_security.Value, true);
_select_child_order(ot);
}
void _select_child_order(CustomOneofCase ot)
{
_child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
if (_child_order == null)
_child_order = child_order_types.FirstOrDefault();
RaisePropertyChanged(nameof(child_order));
}
void _select_hedge_order()
{
CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ?
_inline_props.selected_hedge_order_type.value :
model.factory.default_order_type(_security.Value, true);
_select_hedge_order(ot);
}
void _select_hedge_order(CustomOneofCase ot)
{
_hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot);
if (_hedge_order == null)
_hedge_order = hedge_order_types.FirstOrDefault();
RaisePropertyChanged(nameof(hedge_order));
}
void _validate()
{
if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
set_error(nameof(child_order), string.Empty, true);
else clear_error(nameof(child_order));
if ( (_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors))
set_error(nameof(hedge_order), string.Empty, true);
else clear_error(nameof(hedge_order));
}
}
}
}
@@ -0,0 +1,174 @@
using bts.api;
using bts.api.orderman;
using mbts.ui;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark
{
static partial class OrderTypeVMFactory
{
class InlineLeanOrderProperties
{
public InlineLeanOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types)
{
ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
cross_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false);
max_chase_ticks = new InlineUserProperty<uint>(10, false);
}
public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
public readonly InlineUserProperty<bts.spark.QuantityMeasure> cross_threshold;
public readonly InlineUserProperty<uint> max_chase_ticks;
}
class LeanOrderVM : OrderTypeVMBase<LeanOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable
{
readonly IObservable<SecurityImmutable> _security_source;
SecurityImmutable? _security;
ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
InlineLeanOrderProperties _inline_props;
IOrderTypeVM _child_order;
IDisposable _dispose, _child_order_errors_sub;
public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
public uint max_chase_ticks { get; set; } = 10;
public LeanOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
: this(model, security_source, security_source.Select(s =>
new InlineLeanOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
public LeanOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
IObservable<InlineLeanOrderProperties> inline_properties) : base(model)
{
_security_source = security_source;
_dispose = Disposable.Create(
security_source.ObserveOnDispatcher()
.Subscribe(s => _security = s),
inline_properties.ObserveOnDispatcher()
.Subscribe(p => {
if (_order_types.Count == 0 || p.child_order_types.force_override)
{
_order_types.SetItems(p.child_order_types.value);
}
if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override))
{
_select_child_order(p.selected_child_order_type.value);
}
if (p.cross_threshold.force_override)
{
cross_threshold = p.cross_threshold.value;
RaisePropertyChanged(nameof(cross_threshold));
}
if (p.max_chase_ticks.force_override)
{
max_chase_ticks = p.max_chase_ticks.value;
RaisePropertyChanged(nameof(max_chase_ticks));
}
_inline_props = p;
_validate();
})
);
_validate();
}
public override void assign_to(CustomOrderDefinition value)
{
if (_child_order == null)
_select_child_order(model.factory.default_order_type(_security.Value, true));
_validate();
if (!HasErrors)
{
var i = factory.lean_order();
i.CrossThreshold = cross_threshold;
i.MaxChaseTicks = max_chase_ticks;
child_order.assign_to(i.Child);
value.Lean = i;
}
}
public ICollection<IOrderTypeVM> child_order_types
{
get
{
if (_child_order_choices == null)
_child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
return _child_order_choices;
}
}
public IOrderTypeVM child_order
{
get
{
init();
return _child_order;
}
set
{
Disposable.dispose(ref _child_order_errors_sub);
_child_order = value;
_child_order?.init();
if (_child_order is INotifyDataErrorInfo ndei)
{
ndei.ErrorsChanged += on_errors_changed;
void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
_validate();
_child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
}
_validate();
RaisePropertyChanged(nameof(child_order));
}
}
public void Dispose()
{
Disposable.dispose(ref _dispose);
if (_child_order_choices != null)
_child_order_choices.OfType<IDisposable>().DisposeAll();
}
public override void init()
{
if (_child_order == null && _security.HasValue)
_select_child_order();
_validate();
}
void _select_child_order()
{
CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
_inline_props.selected_child_order_type.value :
model.factory.default_order_type(_security.Value, true);
_select_child_order(ot);
}
void _select_child_order(CustomOneofCase ot)
{
_child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
if (_child_order == null)
_child_order = child_order_types.FirstOrDefault();
RaisePropertyChanged(nameof(child_order));
}
void _validate()
{
if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
set_error(nameof(child_order), string.Empty, true);
else clear_error(nameof(child_order));
}
}
}
}
@@ -15,8 +15,9 @@ namespace mbts.spark {
public static IOrderTypeVM stop_limit(OrdersModel model) => new StopLimitOrderVM(model);
public static IOrderTypeVM time_box(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TimeBoxOrderVM(model, security_source);
public static IOrderTypeVM tick(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TickOrderVM(model, security_source);
public static IOrderTypeVM join(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TickOrderVM(model, security_source);
public static IOrderTypeVM leader(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TickOrderVM(model, security_source);
public static IOrderTypeVM lean(OrdersModel model, IObservable<SecurityImmutable> security_source) => new LeanOrderVM(model, security_source);
public static IOrderTypeVM join(OrdersModel model, IObservable<SecurityImmutable> security_source) => new JoinOrderVM(model, security_source);
public static IOrderTypeVM top(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TopOrderVM(model, security_source);
public static IOrderTypeVM iceberg(OrdersModel model, IObservable<SecurityImmutable> security_source) => new IcebergOrderVM(model, security_source);
public static IOrderTypeVM spreader(OrdersModel model, IObservable<SecurityImmutable> security_source) => new SpreaderOrderVM(model, security_source);
@@ -31,8 +32,9 @@ namespace mbts.spark {
case CustomOneofCase.StopLimit: return stop_limit(model);
case CustomOneofCase.TimeBox: return time_box(model, security_source);
case CustomOneofCase.Tick: return tick(model, security_source);
case CustomOneofCase.Lean: return lean(model, security_source);
case CustomOneofCase.Join: return join(model, security_source);
case CustomOneofCase.Leader: return leader(model, security_source);
case CustomOneofCase.Top: return top(model, security_source);
case CustomOneofCase.Iceberg: return iceberg(model, security_source);
case CustomOneofCase.Spreader: return spreader(model, security_source);
default: throw new NotImplementedException();
@@ -22,9 +22,9 @@ namespace mbts.spark
ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
min_ticks_off_on_deploy = new InlineUserProperty<uint>(0, false);
min_tick_offset_on_deploy = new InlineUserProperty<uint>(0, false);
cross_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
new bts.spark.QuantityMeasure() { Absolute = 1}, false);
new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false);
cross_ticks = new InlineUserProperty<uint>(0, false);
max_chase_ticks = new InlineUserProperty<uint>(10, false);
pay_up_on_toward = new InlineUserProperty<bool>(true, false);
@@ -32,7 +32,7 @@ namespace mbts.spark
public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
public readonly InlineUserProperty<uint> min_ticks_off_on_deploy;
public readonly InlineUserProperty<uint> min_tick_offset_on_deploy;
public readonly InlineUserProperty<bts.spark.QuantityMeasure> cross_threshold;
public readonly InlineUserProperty<uint> cross_ticks;
public readonly InlineUserProperty<uint> max_chase_ticks;
@@ -49,8 +49,8 @@ namespace mbts.spark
IOrderTypeVM _child_order;
IDisposable _dispose, _child_order_errors_sub;
public uint min_ticks_off_on_deploy { get; set; } = 0;
public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Absolute = 1 };
public uint min_tick_offset_on_deploy { get; set; } = 0;
public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
public uint cross_ticks { get; set; } = 0;
public uint max_chase_ticks { get; set; } = 10;
public bool pay_up_on_toward { get; set; } = true;
@@ -76,10 +76,10 @@ namespace mbts.spark
{
_select_child_order(p.selected_child_order_type.value);
}
if (p.min_ticks_off_on_deploy.force_override)
if (p.min_tick_offset_on_deploy.force_override)
{
min_ticks_off_on_deploy = p.min_ticks_off_on_deploy.value;
RaisePropertyChanged(nameof(min_ticks_off_on_deploy));
min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value;
RaisePropertyChanged(nameof(min_tick_offset_on_deploy));
}
if (p.cross_threshold.force_override)
{
@@ -116,7 +116,7 @@ namespace mbts.spark
if (!HasErrors)
{
var i = factory.tick_order();
i.MinTicksOffOnDeploy = min_ticks_off_on_deploy;
i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy;
i.CrossThreshold = cross_threshold;
i.CrossTicks = cross_ticks;
i.MaxChaseTicks = max_chase_ticks;
@@ -0,0 +1,174 @@
using bts.api;
using bts.api.orderman;
using mbts.ui;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using static bts.api.orderman.CustomOrderDefinition;
namespace mbts.spark
{
static partial class OrderTypeVMFactory
{
class InlineTopOrderProperties
{
public InlineTopOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection<CustomOneofCase> child_order_types)
{
ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types");
this.selected_child_order_type = new InlineUserProperty<CustomOneofCase>(selected_child_order_type, true);
this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
watch_level_tick_offset = new InlineUserProperty<uint>(0, false);
top_threshold = new InlineUserProperty<bts.spark.QuantityMeasure>(
new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }, false);
}
public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
public readonly InlineUserProperty<uint> watch_level_tick_offset;
public readonly InlineUserProperty<bts.spark.QuantityMeasure> top_threshold;
}
class TopOrderVM : OrderTypeVMBase<TopOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable
{
readonly IObservable<SecurityImmutable> _security_source;
SecurityImmutable? _security;
ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _child_order_choices;
InlineTopOrderProperties _inline_props;
IOrderTypeVM _child_order;
IDisposable _dispose, _child_order_errors_sub;
public uint watch_level_tick_offset { get; set; } = 0;
public bts.spark.QuantityMeasure top_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 };
public TopOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source)
: this(model, security_source, security_source.Select(s =>
new InlineTopOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { }
public TopOrderVM(OrdersModel model, IObservable<SecurityImmutable> security_source,
IObservable<InlineTopOrderProperties> inline_properties) : base(model)
{
_security_source = security_source;
_dispose = Disposable.Create(
security_source.ObserveOnDispatcher()
.Subscribe(s => _security = s),
inline_properties.ObserveOnDispatcher()
.Subscribe(p => {
if (_order_types.Count == 0 || p.child_order_types.force_override)
{
_order_types.SetItems(p.child_order_types.value);
}
if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override))
{
_select_child_order(p.selected_child_order_type.value);
}
if (p.watch_level_tick_offset.force_override)
{
watch_level_tick_offset = p.watch_level_tick_offset.value;
RaisePropertyChanged(nameof(watch_level_tick_offset));
}
if (p.top_threshold.force_override)
{
top_threshold = p.top_threshold.value;
RaisePropertyChanged(nameof(top_threshold));
}
_inline_props = p;
_validate();
})
);
_validate();
}
public override void assign_to(CustomOrderDefinition value)
{
if (_child_order == null)
_select_child_order(model.factory.default_order_type(_security.Value, true));
_validate();
if (!HasErrors)
{
var i = factory.top_order();
i.WatchLevelTickOffset = watch_level_tick_offset;
i.TopThreshold = top_threshold;
child_order.assign_to(i.Child);
value.Top = i;
}
}
public ICollection<IOrderTypeVM> child_order_types
{
get
{
if (_child_order_choices == null)
_child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_order_types, ot => create(ot, model, _security_source));
return _child_order_choices;
}
}
public IOrderTypeVM child_order
{
get
{
init();
return _child_order;
}
set
{
Disposable.dispose(ref _child_order_errors_sub);
_child_order = value;
_child_order?.init();
if (_child_order is INotifyDataErrorInfo ndei)
{
ndei.ErrorsChanged += on_errors_changed;
void on_errors_changed(object s, DataErrorsChangedEventArgs e) =>
_validate();
_child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed);
}
_validate();
RaisePropertyChanged(nameof(child_order));
}
}
public void Dispose()
{
Disposable.dispose(ref _dispose);
if (_child_order_choices != null)
_child_order_choices.OfType<IDisposable>().DisposeAll();
}
public override void init()
{
if (_child_order == null && _security.HasValue)
_select_child_order();
_validate();
}
void _select_child_order()
{
CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ?
_inline_props.selected_child_order_type.value :
model.factory.default_order_type(_security.Value, true);
_select_child_order(ot);
}
void _select_child_order(CustomOneofCase ot)
{
_child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot);
if (_child_order == null)
_child_order = child_order_types.FirstOrDefault();
RaisePropertyChanged(nameof(child_order));
}
void _validate()
{
if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors))
set_error(nameof(child_order), string.Empty, true);
else clear_error(nameof(child_order));
}
}
}
}
@@ -207,7 +207,7 @@ namespace mbts.ui {
public static BTSColor tick_order { get { return new BTSColor(31, 4, 57);}}
public static BTSColor lean_order { get { return new BTSColor(110, 77, 143);}}
public static BTSColor join_order { get { return new BTSColor(15, 1, 29);}}
public static BTSColor leader_order { get { return new BTSColor(40, 9, 72);}}
public static BTSColor top_order { get { return new BTSColor(40, 9, 72);}}
}
public static class AW2 {
@@ -180,18 +180,17 @@
<ColumnDefinition Width="12"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<TextBlock VerticalAlignment="Center">Min Ticks Off</TextBlock>
<c:TickUpDownUInt Grid.Column="2" Value="{Binding min_ticks_off_on_deploy}"/>
<TextBlock Grid.Row="1" VerticalAlignment="Center">Cross Thresh</TextBlock>
<uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding cross_threshold}"/>
<TextBlock Grid.Row="3" VerticalAlignment="Center">Cross Thresh</TextBlock>
<uag:QuantityMeasureControl Grid.Row="3" Grid.Column="2" QuantityMeasure="{Binding cross_threshold}"/>
<TextBlock Grid.Row="5" VerticalAlignment="Center">Cross Ticks</TextBlock>
<c:TickUpDownUInt Grid.Row="5" Grid.Column="2" Value="{Binding cross_ticks}"/>
<TextBlock Grid.Row="7" VerticalAlignment="Center">Max Chase Ticks</TextBlock>
<c:TickUpDownUInt Grid.Row="7" Grid.Column="2" Value="{Binding max_chase_ticks}"/>
<CheckBox Grid.Row="9" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding pay_up_on_toward}">Pay Up on Toward</CheckBox>
<TextBlock Grid.Row="6">Child</TextBlock>
<TextBlock Grid.Row="3" VerticalAlignment="Center">Cross Ticks</TextBlock>
<c:TickUpDownUInt Grid.Row="3" Grid.Column="2" Value="{Binding cross_ticks}"/>
<TextBlock Grid.Row="5" VerticalAlignment="Center">Max Chase Ticks</TextBlock>
<c:TickUpDownUInt Grid.Row="5" Grid.Column="2" Value="{Binding max_chase_ticks}"/>
<CheckBox Grid.Row="7" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding pay_up_on_toward}">Pay Up on Toward</CheckBox>
<TextBlock Grid.Row="9" VerticalAlignment="Center">Min Initial Tick Offset</TextBlock>
<c:TickUpDownUInt Grid.Row="9" Grid.Column="2" Value="{Binding min_tick_offset_on_deploy}"/>
<TextBlock Grid.Row="11">Child</TextBlock>
<uag:OrderDetailsPopupControl
Grid.Row="11" Grid.Column="2"
IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
@@ -201,7 +200,91 @@
/>
</Grid>
</DataTemplate>
</usp:OrderModificationTemplateSelector.TickOrderTemplate>
</usp:OrderModificationTemplateSelector.TickOrderTemplate>
<usp:OrderModificationTemplateSelector.LeanOrderTemplate>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="12"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Row="1" VerticalAlignment="Center">Cross Thresh</TextBlock>
<uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding cross_threshold}"/>
<TextBlock Grid.Row="3" VerticalAlignment="Center">Max Chase Ticks</TextBlock>
<c:TickUpDownUInt Grid.Row="3" Grid.Column="2" Value="{Binding max_chase_ticks}"/>
<TextBlock Grid.Row="5">Child</TextBlock>
<uag:OrderDetailsPopupControl
Grid.Row="5" Grid.Column="2"
IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
ItemsSource="{Binding child_order_types}"
SelectedItem="{Binding child_order}"
HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
/>
</Grid>
</DataTemplate>
</usp:OrderModificationTemplateSelector.LeanOrderTemplate>
<usp:OrderModificationTemplateSelector.JoinOrderTemplate>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="12"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Row="1" VerticalAlignment="Center">Join Thresh</TextBlock>
<uag:QuantityMeasureControl Grid.Row="1" Grid.Column="2" QuantityMeasure="{Binding join_threshold}"/>
<CheckBox Grid.Row="3" Grid.Column="2" VerticalAlignment="Center" Margin="0,0,0,0" IsChecked="{Binding enable_hedge}">Enable Hedge</CheckBox>
<TextBlock Grid.Row="5" VerticalAlignment="Center" IsEnabled="{Binding enable_hedge}" >Hedge Ticks</TextBlock>
<c:TickUpDownInt Grid.Row="5" Grid.Column="2" IsEnabled="{Binding enable_hedge}" Value="{Binding hedge_ticks}"/>
<TextBlock Grid.Row="7">Hedge</TextBlock>
<uag:OrderDetailsPopupControl
Grid.Row="7" Grid.Column="2"
IsEnabled="{Binding enable_hedge}"
IsOpen="{Binding hedge_order.editable_properties_open, FallbackValue=False}"
ItemsSource="{Binding hedge_order_types}"
SelectedItem="{Binding hedge_order}"
HasEditableProperties="{Binding hedge_order.has_editable_properties, FallbackValue=False}"
/>
<TextBlock Grid.Row="9" VerticalAlignment="Center">Min Initial Tick Offset</TextBlock>
<c:TickUpDownUInt Grid.Row="9" Grid.Column="2" Value="{Binding min_tick_offset_on_deploy}"/>
<TextBlock Grid.Row="11">Child</TextBlock>
<uag:OrderDetailsPopupControl
Grid.Row="11" Grid.Column="2"
IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
ItemsSource="{Binding child_order_types}"
SelectedItem="{Binding child_order}"
HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
/>
</Grid>
</DataTemplate>
</usp:OrderModificationTemplateSelector.JoinOrderTemplate>
<usp:OrderModificationTemplateSelector.IcebergOrderTemplate>
<DataTemplate>
<Grid>
@@ -19,7 +19,7 @@ using System.Windows.Media.Animation;
namespace mbts.spark {
partial class LadderGridHost : Control {
const int _min_row_count = 501, _max_row_count = 2001, _column_min_width = 8;
const int _min_row_count = 1001, _max_row_count = 2001, _column_min_width = 8;
int _row_count = _min_row_count;
readonly VisualHost _visualHost = new VisualHost();
@@ -529,7 +529,7 @@ namespace mbts.spark {
}
}
// Renders the grid lines
//_visualHost.AddVisualChild(_gridvis);
_visualHost.AddVisualChild(_gridvis);
_visualHost.AddVisualChild(_mid_mkt_break_vis);
_visualHost.AddVisualChild(_ask_mkt_break_vis);
_visualHost.AddVisualChild(_bid_mkt_break_vis);
@@ -28,8 +28,9 @@ namespace mbts.spark.utilities {
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.TimeBox,
CustomOrderDefinition.CustomOneofCase.Tick,
CustomOrderDefinition.CustomOneofCase.Lean,
CustomOrderDefinition.CustomOneofCase.Join,
CustomOrderDefinition.CustomOneofCase.Leader,
CustomOrderDefinition.CustomOneofCase.Top,
}, _spreader_types = new[] {
CustomOrderDefinition.CustomOneofCase.Spreader,
CustomOrderDefinition.CustomOneofCase.Iceberg,
@@ -186,6 +187,22 @@ namespace mbts.spark.utilities {
Child = custom_order(),
CrossThreshold = new QuantityMeasure(),
};
public LeanOrderDefinition lean_order() => new LeanOrderDefinition
{
Child = custom_order(),
CrossThreshold = new QuantityMeasure(),
};
public JoinOrderDefinition join_order() => new JoinOrderDefinition
{
Child = custom_order(),
JoinThreshold = new QuantityMeasure(),
};
public TopOrderDefinition top_order() => new TopOrderDefinition
{
Child = custom_order(),
TopThreshold = new QuantityMeasure(),
};
public SpreaderOrderDefinition spreader_order() => new SpreaderOrderDefinition { ExecutionStrategy = new ExecutionStrategy() };
@@ -199,6 +216,9 @@ namespace mbts.spark.utilities {
case CustomOrderDefinition.CustomOneofCase.Iceberg: rv.Iceberg = iceberg_order(); break;
case CustomOrderDefinition.CustomOneofCase.TimeBox: rv.TimeBox = time_box_order(); break;
case CustomOrderDefinition.CustomOneofCase.Tick: rv.Tick = tick_order(); break;
case CustomOrderDefinition.CustomOneofCase.Lean: rv.Lean = lean_order(); break;
case CustomOrderDefinition.CustomOneofCase.Join: rv.Join = join_order(); break;
case CustomOrderDefinition.CustomOneofCase.Top: rv.Top = top_order(); break;
case CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = spreader_order(); break;
}
return rv;
@@ -214,7 +234,10 @@ namespace mbts.spark.utilities {
case CustomOrderDefinition.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.Iceberg: return new OrderMetadata { KeyBinding = "I", Color = BTSColors.pale_blue.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.TimeBox: return new OrderMetadata { KeyBinding = "TB", Color = BTSColors.purple.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.red_orange.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.tick_order };
case CustomOrderDefinition.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order };
case CustomOrderDefinition.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order };
case CustomOrderDefinition.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order };
case CustomOrderDefinition.CustomOneofCase.Spreader: goto default;
case CustomOrderDefinition.CustomOneofCase.None: goto default;
default: return _default_order_metadata;
@@ -228,7 +251,10 @@ namespace mbts.spark.utilities {
case OrderState.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() };
case OrderState.CustomOneofCase.Iceberg: return new OrderMetadata { KeyBinding = "I", Color = BTSColors.pale_blue.rgb_color() };
case OrderState.CustomOneofCase.TimeBox: return new OrderMetadata { KeyBinding = "TB", Color = BTSColors.purple.rgb_color() };
case OrderState.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.red_orange.rgb_color() };
case OrderState.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.tick_order };
case OrderState.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order };
case OrderState.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order };
case OrderState.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order };
case OrderState.CustomOneofCase.Spreader: goto default;
case OrderState.CustomOneofCase.None: goto default;
default: return _default_order_metadata;
@@ -250,6 +276,9 @@ namespace mbts.spark.utilities {
case nameof(SpreaderOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Spreader;
case nameof(TimeBoxOrderDefinition): return CustomOrderDefinition.CustomOneofCase.TimeBox;
case nameof(TickOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Tick;
case nameof(LeanOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Lean;
case nameof(JoinOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Join;
case nameof(TopOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Top;
default: throw new ArgumentException($"Unable to match '{order_type_def?.Descriptor.Name}' to an order definition type");
}
}
+13 -9
View File
@@ -65,11 +65,12 @@ message CustomOrderDefinition
SpreaderOrderDefinition spreader = 16;
TimeBoxOrderDefinition time_box = 17;
TickOrderDefinition tick = 18;
JoinOrderDefinition join = 19;
LeaderOrderDefinition leader = 20;
LeanOrderDefinition lean = 19;
JoinOrderDefinition join = 20;
TopOrderDefinition top = 21;
}
}
// Custom order definitions
message MarketOrderDefinition {}
message LimitOrderDefinition {}
@@ -79,9 +80,10 @@ message IcebergOrderDefinition {double show_quantity = 1; CustomOrderDefinition
message SpreaderOrderDefinition {api.Security security = 1; spark.ExecutionStrategy execution_strategy = 2;}
message TimeBoxOrderDefinition {google.protobuf.Timestamp start = 1; google.protobuf.Timestamp stop = 2;CustomOrderDefinition child = 3;}
message TickOrderDefinition {uint32 min_ticks_off_on_deploy = 1; spark.QuantityMeasure cross_threshold = 2; uint32 cross_ticks = 3; uint32 max_chase_ticks = 4; bool pay_up_on_toward = 5; CustomOrderDefinition child = 6; }
message JoinOrderDefinition {uint32 min_ticks_off_on_deploy = 1; spark.QuantityMeasure join_threshold = 2; CustomOrderDefinition cover = 3; uint32 cover_ticks = 4; CustomOrderDefinition child = 5;}
message LeaderOrderDefinition {uint32 watch_level_ticks_off = 1; spark.QuantityMeasure lead_threshold = 2; CustomOrderDefinition cover = 3; uint32 cover_ticks = 4; CustomOrderDefinition child = 5;}
message TickOrderDefinition {uint32 min_tick_offset_on_deploy = 1; spark.QuantityMeasure cross_threshold = 2; uint32 cross_ticks = 3; uint32 max_chase_ticks = 4; bool pay_up_on_toward = 5; CustomOrderDefinition child = 6; }
message LeanOrderDefinition {spark.QuantityMeasure cross_threshold = 1; uint32 max_chase_ticks = 2; CustomOrderDefinition child = 3; }
message JoinOrderDefinition {uint32 min_tick_offset_on_deploy = 1; spark.QuantityMeasure join_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;}
message TopOrderDefinition {uint32 watch_level_tick_offset = 1; spark.QuantityMeasure top_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;}
message OrderRecord {
uint32 key = 1 [(bts.api.key)=true];
@@ -114,8 +116,9 @@ message OrderState {
SpreaderOrderState spreader = 14;
TimeBoxOrderState time_box = 15;
TickOrderState tick = 17;
JoinOrderState join = 18;
LeaderOrderState leader = 19;
LeanOrderState lean = 18;
JoinOrderState join = 19;
TopOrderState top = 20;
}
}
@@ -169,8 +172,9 @@ message IcebergOrderState {}
message SpreaderOrderState {SpreaderChildKind child_kind = 1;}
message TimeBoxOrderState {}
message TickOrderState {}
message LeanOrderState {}
message JoinOrderState {}
message LeaderOrderState {}
message TopOrderState {}
enum OrderStatus {
@@ -13,6 +13,9 @@
#include "server/sparkd/orderman/orders/NativeOrder.h"
#include "server/sparkd/orderman/orders/TimeBoxOrder.h"
#include "server/sparkd/orderman/orders/book_algos/TickOrder.h"
#include "server/sparkd/orderman/orders/book_algos/LeanOrder.h"
#include "server/sparkd/orderman/orders/book_algos/JoinOrder.h"
#include "server/sparkd/orderman/orders/book_algos/TopOrder.h"
#include <limits>
#include <mutex>
@@ -124,11 +127,14 @@ Order &OrderFactory::allocate(OrderKey k, OrderKey pk,
case CustomOrderDefinition::kTick:
order_ptr.reset (new orderman::TickOrder());
break;
case CustomOrderDefinition::kLean:
order_ptr.reset (new orderman::LeanOrder());
break;
case CustomOrderDefinition::kJoin:
//order_ptr.reset (new orderman::JoinOrder());
order_ptr.reset (new orderman::JoinOrder());
break;
case CustomOrderDefinition::kLeader:
//order_ptr.reset (new orderman::LeadOrder());
case CustomOrderDefinition::kTop:
order_ptr.reset (new orderman::TopOrder());
break;
case CustomOrderDefinition::CUSTOM_NOT_SET:
bts_assert(false);
@@ -82,8 +82,9 @@ void NativeOrder::on_init_new(OrderDefinition const &def,
case CustomOrderDefinition::kSpreader:
case CustomOrderDefinition::kTimeBox:
case CustomOrderDefinition::kTick:
case CustomOrderDefinition::kLean:
case CustomOrderDefinition::kJoin:
case CustomOrderDefinition::kLeader:
case CustomOrderDefinition::kTop:
case CustomOrderDefinition::CUSTOM_NOT_SET:
bts_assert(false);
break;
@@ -350,8 +351,9 @@ void NativeOrder::on_activate(Price p, Quantity q,
case CustomOrderDefinition::kSpreader:
case CustomOrderDefinition::kTimeBox:
case CustomOrderDefinition::kTick:
case CustomOrderDefinition::kLean:
case CustomOrderDefinition::kJoin:
case CustomOrderDefinition::kLeader:
case CustomOrderDefinition::kTop:
case CustomOrderDefinition::CUSTOM_NOT_SET:
bts_assert(false);
break;
@@ -839,8 +841,9 @@ void NativeOrder::init_fix() {
case CustomOrderDefinition::kSpreader:
case CustomOrderDefinition::kTimeBox:
case CustomOrderDefinition::kTick:
case CustomOrderDefinition::kLean:
case CustomOrderDefinition::kJoin:
case CustomOrderDefinition::kLeader:
case CustomOrderDefinition::kTop:
case CustomOrderDefinition::CUSTOM_NOT_SET:
bts_assert(false);
@@ -989,8 +992,9 @@ NativeOrder::get_native_state(api::orderman::OrderState &st) {
case OrderState::kSpreader:
case OrderState::kTimeBox:
case OrderState::kTick:
case OrderState::kLean:
case OrderState::kJoin:
case OrderState::kLeader:
case OrderState::kTop:
case OrderState::CUSTOM_NOT_SET:
break;
}
@@ -9,12 +9,23 @@ namespace orderman {
using namespace api::orderman;
struct BookAlgo::PImpl
{
PImpl() : services(nullptr), child_builder(), fake_detached_child(false),
supports_hedge(false)
{
}
OrderServices* services;
OrderBuilder child_builder;
bool fake_detached_child;
bool supports_hedge;
};
BookAlgo::BookAlgo() : _services(nullptr), _def(), _state(),
_child_builder(), _child(), _child_state(),
_fake_detached_child(false),
_supports_hedge(false),
_hedge_builder(), _hedge(), _hedge_state()
BookAlgo::BookAlgo() : me(new PImpl()),
_def(), _state(),
_child(), _child_state(),
_hedges(), _hedges_state()
{
}
@@ -28,18 +39,19 @@ const api::orderman::OrderDefinition& BookAlgo::definition() const
void BookAlgo::on_init_new(const api::orderman::OrderDefinition& def,
const PreActivationOrderServices &services)
{
_services = nullptr;
me->services = nullptr;
_def = def;
OrderDefinition child_def = def;
setup_child(def, services, child_def);
_child_builder = OrderBuilder(key(), child_def, services, 1);
me->child_builder = OrderBuilder(key(), child_def, services, 1);
OrderDefinition hedge_def = def;
_supports_hedge = setup_hedge(def, services, hedge_def);
if(_supports_hedge)
me->supports_hedge = setup_hedge(def, services, hedge_def);
if(me->supports_hedge)
_hedge_builder = OrderBuilder(key(), hedge_def, services, 4);
_tick_size = services.sec_db.resolve(SecurityKey(def.security_key()))->contract_spec().low_tick();
transition(ORDER_STATUS_INACTIVE);
}
@@ -78,15 +90,15 @@ void BookAlgo::on_init_recovered(const api::orderman::OrderRecord& rec,
void BookAlgo::on_activate(Price p, Quantity q, OrderServices& services)
{
bts_assert(!_services);
_services = &services;
_child_builder.activate(services);
if(_supports_hedge)
bts_assert(!me->services);
me->services = &services;
me->child_builder.activate(services);
if(me->supports_hedge)
_hedge_builder.activate(services);
switch (_state.status())
{
case ORDER_STATUS_INACTIVE:
_child = _child_builder.build();
_child = me->child_builder.build();
_state.set_price(p.value());
_state.set_quantity(q.value());
services.child_updates.sub(key(),
@@ -132,7 +144,7 @@ void BookAlgo::on_update(Price p, Quantity q)
case ORDER_STATUS_WORKING:
_state.set_price(p.value());
_state.set_quantity(q.value());
if(!_fake_detached_child)
if(!me->fake_detached_child)
_child.update(p,q);
break;
case ORDER_STATUS_PENDING_WORKING:
@@ -189,14 +201,10 @@ void BookAlgo::on_cancel()
transition(ORDER_STATUS_CANCELED);
break;
case ORDER_STATUS_WORKING:
if(!_fake_detached_child)
if(!me->fake_detached_child)
_child.cancel();
bts_assert(_hedge.size() == _hedge_state.size());
for(const auto& i : _hedge_state)
{
if(i.second.status() == ORDER_STATUS_WORKING)
_hedge[i.first].crack();
}
for(auto& i : _hedges)
i.crack();
transition(ORDER_STATUS_CANCELED);
break;
case ORDER_STATUS_PENDING_WORKING:
@@ -245,10 +253,10 @@ void BookAlgo::transition(api::orderman::OrderStatus new_status, std::string msg
void BookAlgo::on_child_order_update(const OrderStateUpdateEvent& ev)
{
if(_fake_detached_child)
if(me->fake_detached_child)
return;
if(ev.key != _child.key())
_hedge_state[ev.key] = ev.state;
_hedges_state[ev.key] = ev.state;
else
{
api::orderman::OrderState orig_state = _child_state;
@@ -260,11 +268,13 @@ void BookAlgo::on_child_order_update(const OrderStateUpdateEvent& ev)
{
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
send_hedge(orig_state, ev);
if(me->supports_hedge)
send_hedge(orig_state, ev);
break;
case ORDER_STATUS_COMPLETED:
transition(ORDER_STATUS_COMPLETED);
send_hedge(orig_state, ev);
if(me->supports_hedge)
send_hedge(orig_state, ev);
break;
case ORDER_STATUS_DISCONNECTED:
@@ -306,7 +316,29 @@ void BookAlgo::report_state()
merged_state.set_filled_quantity(_child_state.filled_quantity());
merged_state.set_last_price(_child_state.last_price());
merged_state.set_avg_price(_child_state.avg_price());
_services->report_state(merged_state);
me->services->report_state(merged_state);
}
void BookAlgo::payup(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() + _tick_size * cross_ticks;
_child.update(Price(new_price), Quantity(_state.quantity()));
report_state();
}
void BookAlgo::paydown(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() - _tick_size * cross_ticks;
_child.update(Price(new_price), Quantity(_state.quantity()));
report_state();
}
void BookAlgo::detach()
{
me->fake_detached_child = true;
_child.crack();
transition(ORDER_STATUS_CANCELED);
report_state();
}
void BookAlgo::on_book_update(const bts::orderman::BookUpdateEvent&) {}
@@ -38,22 +38,28 @@ protected:
virtual void on_book_update(const bts::orderman::BookUpdateEvent&);
virtual void transition(api::orderman::OrderStatus new_state, std::string = "");
virtual void report_state();
virtual void report_state();
protected:
OrderServices* _services;
virtual void payup(const md::PriceSize&, uint32_t cross_ticks = 0);
virtual void paydown(const md::PriceSize&, uint32_t cross_ticks = 0);
void detach();
private:
struct PImpl;
std::unique_ptr<PImpl> me;
protected:
api::orderman::OrderDefinition _def;
api::orderman::OrderState _state;
OrderBuilder _child_builder;
ChildOrder _child;
api::orderman::OrderState _child_state;
bool _fake_detached_child;
bool _supports_hedge;
OrderBuilder _hedge_builder;
boost::container::flat_map<OrderKey, ChildOrder> _hedge;
boost::container::flat_map<OrderKey, api::orderman::OrderState> _hedge_state;
OrderBuilder _hedge_builder;
std::vector<ChildOrder> _hedges;
using HedgeStateMap = boost::container::flat_map<OrderKey, api::orderman::OrderState>;
HedgeStateMap _hedges_state;
double _tick_size;
};
}}
@@ -0,0 +1,166 @@
#include "JoinOrder.h"
#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h"
#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/utils/PBUtils.h"
#include <google/protobuf/timestamp.pb.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
struct JoinOrder::PImpl
{
PImpl() {}
uint32_t min_tick_offset_on_deploy;
spark::QuantityMeasure join_threshold;
bool enable_hedge;
int hedge_ticks;
OrderDefinition hedge_def;
md::PriceSize opposite_at_inception;
bool did_join;
};
JoinOrder::JoinOrder() : me(new PImpl()) {}
JoinOrder::~JoinOrder() {}
void JoinOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def)
{
_state.mutable_join();
auto const &join_def = parent_def.custom_def().join();
_child_state.set_status(ORDER_STATUS_INACTIVE);
*child_def.mutable_custom_def() = join_def.child();
me->min_tick_offset_on_deploy = join_def.min_tick_offset_on_deploy();
me->join_threshold = join_def.join_threshold();
me->enable_hedge = join_def.enable_hedge();
me->hedge_ticks = join_def.hedge_ticks();
me->did_join = false;
}
bool JoinOrder::setup_hedge(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& hedge_def)
{
auto const &join_def = parent_def.custom_def().join();
if(me->enable_hedge && join_def.has_hedge())
{
*hedge_def.mutable_custom_def() = join_def.hedge();
if(_def.side() == api::SIDE_BUY)
hedge_def.set_side(api::SIDE_SELL);
else
hedge_def.set_side(api::SIDE_BUY);
return true;
}
else
return false;
}
void JoinOrder::send_hedge(const api::orderman::OrderState& orig_state, const OrderStateUpdateEvent& new_state)
{
uint32_t qty = new_state.state.filled_quantity() - orig_state.filled_quantity();
if(qty > 0)
{
double prx = new_state.state.last_price();
if(_def.side() == api::SIDE_BUY) //if this is a buy, I'm going to sell my hedge, nticks higher than the fill price
prx = prx + _tick_size * me->hedge_ticks;
else
prx = prx - _tick_size * me->hedge_ticks;
auto hedge = _hedge_builder.build();
_hedges.push_back(std::move(hedge));
_hedges[_hedges.size()-1].activate(Price(prx), Quantity(qty));
}
}
void JoinOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
{
switch (_state.status())
{
case ORDER_STATUS_WORKING:
switch (_child_state.status())
{
case ORDER_STATUS_INACTIVE:
{
if(_def.side() == api::SIDE_BUY)
me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0];
else
me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0];
LOG(OrderMan, Info, "JoinOrder order {} launching child {}", key().value(), _child.key().value());
_child.activate(Price(_state.price()), Quantity(_state.quantity()));
_child_state.set_status(ORDER_STATUS_PENDING_WORKING);
transition(ORDER_STATUS_WORKING);
report_state();
}
break;
case ORDER_STATUS_WORKING:
{
Quantity thresh = SpreaderUtils::_quantity_threshold(me->join_threshold, Quantity(_state.quantity()));
if(_def.side() == api::SIDE_BUY)
{
const auto& same = book.book.side(api::Side::SIDE_BUY)[0];
if(me->opposite_at_inception.price() > same.price())
{}
else if(!me->did_join && same.size() >= thresh.value())
{
me->did_join = true;
_child.update(Price(same.price()), Quantity(_state.quantity()));
report_state();
}
}
else
{
const auto& same = book.book.side(api::Side::SIDE_SELL)[0];
if(me->opposite_at_inception.price() < same.price())
{}
else if(!me->did_join && same.size() >= thresh.value())
{
me->did_join = true;
_child.update(Price(same.price()), Quantity(_state.quantity()));
report_state();
}
}
}
break;
case ORDER_STATUS_PENDING_WORKING:
break;
// child cannot be in any of these states if we are in the working state
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
break;
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_INACTIVE:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
}
}
@@ -0,0 +1,30 @@
#pragma once
#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h"
namespace bts {
namespace orderman {
class OrderStateUpdateEvent;
class BookUpdateEvent;
class JoinOrder : public BookAlgo
{
public:
JoinOrder();
virtual ~JoinOrder();
protected:
void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def) override;
bool setup_hedge(const api::orderman::OrderDefinition& parent, const PreActivationOrderServices&,
api::orderman::OrderDefinition&) override;
void send_hedge(const api::orderman::OrderState&, const OrderStateUpdateEvent&) override;
void on_book_update(const bts::orderman::BookUpdateEvent&) override;
private:
struct PImpl;
std::unique_ptr<PImpl> me;
};
}}
@@ -0,0 +1,156 @@
#include "LeanOrder.h"
#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h"
#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/utils/PBUtils.h"
#include <google/protobuf/timestamp.pb.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
struct LeanOrder::PImpl
{
PImpl() {}
spark::QuantityMeasure cross_threshold;
uint32_t max_chase_ticks;
md::PriceSize opposite_at_inception;
};
LeanOrder::LeanOrder() : me(new PImpl()) {}
LeanOrder::~LeanOrder() {}
void LeanOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def)
{
_state.mutable_lean();
auto const &lean_def = parent_def.custom_def().lean();
_child_state.set_status(ORDER_STATUS_INACTIVE);
*child_def.mutable_custom_def() = lean_def.child();
me->cross_threshold = lean_def.cross_threshold();
me->max_chase_ticks = lean_def.max_chase_ticks();
}
void LeanOrder::payup(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() + _tick_size * cross_ticks;
double limit = me->opposite_at_inception.price() + _tick_size * me->max_chase_ticks;
if(new_price <= limit)
_child.update(Price(new_price), Quantity(_state.quantity()));
else
{
_child.update(Price(limit), Quantity(_state.quantity()));
detach();
}
report_state();
}
void LeanOrder::paydown(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() - _tick_size * cross_ticks;
double limit = me->opposite_at_inception.price() - _tick_size * me->max_chase_ticks;
if(new_price >= limit)
_child.update(Price(new_price), Quantity(_state.quantity()));
else
{
_child.update(Price(limit), Quantity(_state.quantity()));
detach();
}
report_state();
}
void LeanOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
{
switch (_state.status())
{
case ORDER_STATUS_WORKING:
switch (_child_state.status())
{
case ORDER_STATUS_INACTIVE:
{
if(_def.side() == api::SIDE_BUY)
me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0];
else
me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0];
LOG(OrderMan, Info, "LeanOrder order {} launching child {}", key().value(), _child.key().value());
_child.activate(Price(_state.price()), Quantity(_state.quantity()));
_child_state.set_status(ORDER_STATUS_PENDING_WORKING);
transition(ORDER_STATUS_WORKING);
report_state();
}
break;
case ORDER_STATUS_WORKING:
{
Quantity thresh = SpreaderUtils::_quantity_threshold(me->cross_threshold, Quantity(_state.quantity()));
if(_def.side() == api::SIDE_BUY)
{
const auto& opposite = book.book.side(api::Side::SIDE_SELL)[0];
if(opposite.price() < me->opposite_at_inception.price())
me->opposite_at_inception = opposite; //your lucky day, try to get luckier
else if(opposite.price() > me->opposite_at_inception.price())
payup(opposite); //you missed, payup
else
{
if(opposite.size() <= thresh.value())
payup(opposite);
}
}
else
{
const auto& opposite = book.book.side(api::Side::SIDE_BUY)[0];
if(opposite.price() > me->opposite_at_inception.price())
me->opposite_at_inception = opposite;
else if(opposite.price() < me->opposite_at_inception.price())
paydown(opposite);
else
{
if(opposite.size() <= thresh.value())
paydown(opposite);
}
}
}
break;
case ORDER_STATUS_PENDING_WORKING:
break;
// child cannot be in any of these states if we are in the working state
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
break;
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_INACTIVE:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
}
}
@@ -0,0 +1,30 @@
#pragma once
#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h"
namespace bts {
namespace orderman {
class OrderStateUpdateEvent;
class BookUpdateEvent;
class LeanOrder : public BookAlgo
{
public:
LeanOrder();
virtual ~LeanOrder();
protected:
void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def) override;
void on_book_update(const bts::orderman::BookUpdateEvent&) override;
private:
void payup(const md::PriceSize& opposite, uint32_t cross_ticks = 0) override;
void paydown(const md::PriceSize& opposite, uint32_t cross_ticks = 0) override;
private:
struct PImpl;
std::unique_ptr<PImpl> me;
};
}}
@@ -14,13 +14,12 @@ struct TickOrder::PImpl
{
PImpl() {}
uint32_t min_ticks_off_on_deploy;
uint32_t min_tick_offset_on_deploy;
spark::QuantityMeasure cross_threshold;
uint32_t cross_ticks;
uint32_t max_chase_ticks;
bool pay_up_on_toward;
double tick_size;
md::PriceSize opposite_at_inception;
};
@@ -29,7 +28,7 @@ TickOrder::TickOrder() : me(new PImpl()) {}
TickOrder::~TickOrder() {}
void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices& svc,
void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def)
{
_state.mutable_tick();
@@ -37,20 +36,18 @@ void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, co
_child_state.set_status(ORDER_STATUS_INACTIVE);
*child_def.mutable_custom_def() = tick_def.child();
me->min_ticks_off_on_deploy = tick_def.min_ticks_off_on_deploy();
me->min_tick_offset_on_deploy = tick_def.min_tick_offset_on_deploy();
me->cross_threshold = tick_def.cross_threshold();
me->cross_ticks = tick_def.cross_ticks();
me->max_chase_ticks = tick_def.max_chase_ticks();
me->cross_threshold = tick_def.cross_threshold();
me->pay_up_on_toward = tick_def.pay_up_on_toward();
me->tick_size = svc.sec_db.resolve(SecurityKey(parent_def.security_key()))->contract_spec().low_tick();
me->pay_up_on_toward = tick_def.pay_up_on_toward();
}
void TickOrder::payup(const md::PriceSize& opposite)
void TickOrder::payup(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() + me->tick_size * me->cross_ticks;
double limit = me->opposite_at_inception.price() + me->tick_size * me->max_chase_ticks;
double new_price = opposite.price() + _tick_size * cross_ticks;
double limit = me->opposite_at_inception.price() + _tick_size * me->max_chase_ticks;
if(new_price <= limit)
_child.update(Price(new_price), Quantity(_state.quantity()));
else
@@ -61,10 +58,10 @@ void TickOrder::payup(const md::PriceSize& opposite)
report_state();
}
void TickOrder::paydown(const md::PriceSize& opposite)
void TickOrder::paydown(const md::PriceSize& opposite, uint32_t cross_ticks)
{
double new_price = opposite.price() - me->tick_size * me->cross_ticks;
double limit = me->opposite_at_inception.price() - me->tick_size * me->max_chase_ticks;
double new_price = opposite.price() - _tick_size * cross_ticks;
double limit = me->opposite_at_inception.price() - _tick_size * me->max_chase_ticks;
if(new_price >= limit)
_child.update(Price(new_price), Quantity(_state.quantity()));
else
@@ -75,14 +72,6 @@ void TickOrder::paydown(const md::PriceSize& opposite)
report_state();
}
void TickOrder::detach()
{
_fake_detached_child = true;
_child.crack();
transition(ORDER_STATUS_CANCELED);
report_state();
}
void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
{
switch (_state.status())
@@ -95,8 +84,8 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
if(_def.side() == api::SIDE_BUY)
{
me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0];
double max_price = me->opposite_at_inception.price() - me->tick_size * me->min_ticks_off_on_deploy;
if(me->min_ticks_off_on_deploy && _state.price() > max_price)
double max_price = me->opposite_at_inception.price() - _tick_size * me->min_tick_offset_on_deploy;
if(me->min_tick_offset_on_deploy && _state.price() > max_price)
{
LOG(OrderMan, Info, "TickOrder order {} repricing child {}", key().value(), _child.key().value());
_state.set_price(max_price);
@@ -112,8 +101,8 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
else
{
me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0];
double min_price = me->opposite_at_inception.price() + me->tick_size * me->min_ticks_off_on_deploy;
if(me->min_ticks_off_on_deploy && _state.price() < min_price)
double min_price = me->opposite_at_inception.price() + _tick_size * me->min_tick_offset_on_deploy;
if(me->min_tick_offset_on_deploy && _state.price() < min_price)
{
LOG(OrderMan, Info, "TickOrder order {} repricing child {}", key().value(), _child.key().value());
_state.set_price(min_price);
@@ -138,16 +127,16 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
if(opposite.price() < me->opposite_at_inception.price())
{
if(me->pay_up_on_toward)
payup(opposite);
payup(opposite, me->cross_ticks);
else
detach();
}
else if(opposite.price() > me->opposite_at_inception.price())
payup(opposite);
payup(opposite, me->cross_ticks);
else
{
if(opposite.size() <= thresh.value())
payup(opposite);
payup(opposite, me->cross_ticks);
}
}
else
@@ -156,16 +145,16 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
if(opposite.price() > me->opposite_at_inception.price())
{
if(me->pay_up_on_toward)
paydown(opposite);
paydown(opposite, me->cross_ticks);
else
detach();
}
else if(opposite.price() < me->opposite_at_inception.price())
paydown(opposite);
paydown(opposite, me->cross_ticks);
else
{
if(opposite.size() <= thresh.value())
paydown(opposite);
paydown(opposite, me->cross_ticks);
}
}
}
@@ -18,11 +18,9 @@ protected:
void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def) override;
void on_book_update(const bts::orderman::BookUpdateEvent&) override;
private:
void payup(const md::PriceSize&);
void paydown(const md::PriceSize&);
void detach();
void payup(const md::PriceSize& opposite, uint32_t cross_ticks) override;
void paydown(const md::PriceSize& opposite, uint32_t cross_ticks) override;
private:
struct PImpl;
@@ -0,0 +1,127 @@
#include "TopOrder.h"
#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h"
#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/utils/PBUtils.h"
#include <google/protobuf/timestamp.pb.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
struct TopOrder::PImpl
{
PImpl() {}
spark::QuantityMeasure cross_threshold;
uint32_t max_chase_ticks;
md::PriceSize opposite_at_inception;
};
TopOrder::TopOrder() : me(new PImpl()) {}
TopOrder::~TopOrder() {}
void TopOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def)
{
_state.mutable_lean();
auto const &lean_def = parent_def.custom_def().lean();
_child_state.set_status(ORDER_STATUS_INACTIVE);
*child_def.mutable_custom_def() = lean_def.child();
me->cross_threshold = lean_def.cross_threshold();
me->max_chase_ticks = lean_def.max_chase_ticks();
}
void TopOrder::on_book_update(const bts::orderman::BookUpdateEvent& book)
{
switch (_state.status())
{
case ORDER_STATUS_WORKING:
switch (_child_state.status())
{
case ORDER_STATUS_INACTIVE:
{
if(_def.side() == api::SIDE_BUY)
me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0];
else
me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0];
LOG(OrderMan, Info, "TopOrder order {} launching child {}", key().value(), _child.key().value());
_child.activate(Price(_state.price()), Quantity(_state.quantity()));
_child_state.set_status(ORDER_STATUS_PENDING_WORKING);
transition(ORDER_STATUS_WORKING);
report_state();
}
break;
case ORDER_STATUS_WORKING:
{
Quantity thresh = SpreaderUtils::_quantity_threshold(me->cross_threshold, Quantity(_state.quantity()));
if(_def.side() == api::SIDE_BUY)
{
const auto& opposite = book.book.side(api::Side::SIDE_SELL)[0];
if(opposite.price() < me->opposite_at_inception.price())
me->opposite_at_inception = opposite; //your lucky day, try to get luckier
else if(opposite.price() > me->opposite_at_inception.price())
payup(opposite); //you missed, payup
else
{
if(opposite.size() <= thresh.value())
payup(opposite);
}
}
else
{
const auto& opposite = book.book.side(api::Side::SIDE_BUY)[0];
if(opposite.price() > me->opposite_at_inception.price())
me->opposite_at_inception = opposite;
else if(opposite.price() < me->opposite_at_inception.price())
paydown(opposite);
else
{
if(opposite.size() <= thresh.value())
paydown(opposite);
}
}
}
break;
case ORDER_STATUS_PENDING_WORKING:
break;
// child cannot be in any of these states if we are in the working state
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
break;
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_INACTIVE:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
}
}
@@ -0,0 +1,27 @@
#pragma once
#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h"
namespace bts {
namespace orderman {
class OrderStateUpdateEvent;
class BookUpdateEvent;
class TopOrder : public BookAlgo
{
public:
TopOrder();
virtual ~TopOrder();
protected:
void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&,
api::orderman::OrderDefinition& child_def) override;
void on_book_update(const bts::orderman::BookUpdateEvent&) override;
private:
struct PImpl;
std::unique_ptr<PImpl> me;
};
}}