Files
spark/src/client/spark/Orders/OrderDataHelper.cs
T

1093 lines
69 KiB
C#

using bts;
using bts.api;
using bts.api.orderman;
using bts.collections;
using bts.spark;
using bts.utils;
using Google.Protobuf;
using Google.Protobuf.Reflection;
using Google.Protobuf.WellKnownTypes;
using mbts.ui;
using mbts.ui.utilities;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Reactive.Linq;
using OrderState = bts.api.orderman.OrderState;
namespace mbts.spark.utilities {
struct ChildAlgoData {
public readonly string name;
public readonly Func<IMessage, CustomOrderDefinition> get_child_from_impl;
public readonly Action<IMessage, CustomOrderDefinition> assign_child_to_impl;
public readonly Func<CustomOrderDefinition, CustomOrderDefinition> get_child;
public readonly Action<CustomOrderDefinition, CustomOrderDefinition> assign_child;
public ChildAlgoData(string name, Func<IMessage, CustomOrderDefinition> get_child_from_impl,
Action<IMessage, CustomOrderDefinition> assign_child_to_impl,
Func<CustomOrderDefinition, CustomOrderDefinition> get_child,
Action<CustomOrderDefinition, CustomOrderDefinition> 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.default_order };
readonly AdminModel _admin_model;
readonly DynamicOrderHelper _dynamic_helper;
readonly IReadOnlyDictionary<OneOf<CustomOrderDefinition.CustomOneofCase, string>, string> _algo_abbreviation_index;
IDisposable _dispose;
[ImportingConstructor]
public OrderFactory(AdminModel admin_model, DynamicOrderHelper dynamic_helper) {
_admin_model = admin_model;
_dynamic_helper = dynamic_helper;
var algo_name_index = new HashSet<OneOf<CustomOrderDefinition.CustomOneofCase, string>>(OneOf<CustomOrderDefinition.CustomOneofCase, string>.ValueEqualityComparer);
// add standard types
algo_name_index.AddRange(
EnumHelper.get_values_except(CustomOrderDefinition.CustomOneofCase.None)
.Select(t => new OneOf<CustomOrderDefinition.CustomOneofCase, string>(t)));
// add dynamic types
algo_name_index.AddRange(dynamic_helper.dynamic_types
.Select(dt => new OneOf<CustomOrderDefinition.CustomOneofCase, string>(dt)));
// build abbreviation index
_algo_abbreviation_index = DisplayNameHelper.get_word_tree_abbreviations(algo_name_index, oneof => oneof.value.ToString(), OneOf<CustomOrderDefinition.CustomOneofCase, string>.ValueEqualityComparer);
}
public IObservable<IReadOnlyDictionary<uint, string>> subscribe_accounts() => _admin_model.on_accounts;
public IObservable<IReadOnlyDictionary<uint, string>> subscribe_users() => _admin_model.on_users;
public IObservable<IReadOnlyList<AccountTuple>> subscribe_account_tuples() => _admin_model.on_account_tuples;
#region Defaults
public CustomOrderDefinition.CustomOneofCase default_order_type(SecurityImmutable security) {
switch (security.ContractCase) {
case Security.ContractOneofCase.Synthetic: return CustomOrderDefinition.CustomOneofCase.Spreader;
default: return CustomOrderDefinition.CustomOneofCase.Limit;
}
}
public TimeInForce default_time_in_force() =>
TimeInForce.Day;
public TimeInForce default_time_in_force(SecurityImmutable security) =>
default_time_in_force();
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types() =>
OrderDataHelper.exchange_order_types;
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable? security) =>
security.HasValue ? default_order_types(security.Value) : OrderDataHelper.exchange_order_types;
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable security) {
switch (security.ContractCase) {
case Security.ContractOneofCase.Synthetic: return OrderDataHelper.spreader_order_types;
default: return OrderDataHelper.exchange_order_types;
}
}
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable? security, bool is_child = false) =>
security.HasValue ? default_order_types(security.Value, is_child) : default_order_types();
public IEnumerable<TimeInForce> default_time_in_forces() =>
EnumHelper.get_values_except(TimeInForce.Undefined);
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable security, bool is_child = false) =>
default_time_in_forces();
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable security, CustomOrderDefinition.CustomOneofCase order_type, bool is_child = false) {
var tifs = default_time_in_forces(security, is_child);
if (order_type != CustomOrderDefinition.CustomOneofCase.Limit) {
tifs = tifs.Except(new[] { TimeInForce.Ioc });
}
return tifs;
}
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable? security, bool is_child = false) =>
security.HasValue ? default_time_in_forces(security.Value, is_child) : default_time_in_forces();
public LadderSettings default_ladder_settings(SecurityImmutable security) {
var settings = LadderSettings.Default;
if (security.ContractCase == Security.ContractOneofCase.Synthetic)
settings.default_order_type = CustomOrderDefinition.CustomOneofCase.Spreader;
return settings;
}
public Dictionary<AlgoKey, AlgoData> default_algos() =>
default_algos((SecurityImmutable?)null);
public Dictionary<AlgoKey, AlgoData> default_algos(SecurityImmutable? security) =>
default_algos(default_order_types(security));
public Dictionary<AlgoKey, AlgoData> default_algos(AlgoFormats algo_format) =>
default_algos(OrderDataHelper.get_format_algo_types(algo_format));
public Dictionary<AlgoKey, AlgoData> default_algos(IEnumerable<CustomOrderDefinition.CustomOneofCase> types) {
var def_map = new Dictionary<AlgoKey, AlgoData>();
foreach (var ot in types.Except(new[] { CustomOrderDefinition.CustomOneofCase.Dynamic, CustomOrderDefinition.CustomOneofCase.Composite })) {
var data = AlgoData.from_custom_def(OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(ot));
def_map[data.key] = data;
}
var dynamic_defs = new List<CustomOrderDefinitionImmutable>();
_dynamic_helper.add_dynamic_order_defs(dynamic_defs, custom_order);
foreach (var dd in dynamic_defs) {
var data = AlgoData.from_custom_def(dd);
def_map[data.key] = data;
}
return def_map;
}
#endregion
public OrderDefinitionImmutable order(SecurityImmutable security) =>
new OrderDefinitionImmutable(order(security, _admin_model.get_default_account()));
public OrderDefinition order(SecurityImmutable security, AccountTuple? account) {
var rv = new OrderDefinition {
SecurityKey = security.Id,
Side = Side.Buy,
TimeInForce = TimeInForce.Day,
CustomDef = custom_order(),
CtiCode = CTICode.CtiCode1,
CustomerOrFirm = CustomerOrFirm.Firm,
// this will be the tag 50 on CME orders
// current user might be okay, but we might also want to get it
// from the store that serves the risk admin gui
ManualOrderIndicator = ManualOrderIndicator.Yes,
User = _admin_model.user.name,
UserId = _admin_model.user.id
};
if (account.HasValue) {
rv.Account = account.Value.name;
rv.AccountId = account.Value.id;
}
return rv;
}
public string abbreviate_algo(CustomOrderDefinitionImmutable defi) =>
abbreviate_algo(_simple_algo_id(defi));
public string abbreviate_algo(OneOf<CustomOrderDefinition.CustomOneofCase, string> id) {
if (id == null)
throw new ArgumentNullException(nameof(id));
if (id.value is string)
return _algo_abbreviation_index.TryGetValue(id, out string abb) ? abb : id.value.ToString();
else if (id.value is CustomOrderDefinition.CustomOneofCase t)
return OrderDataHelper.abbreviate_algo_type(t);
return id.ToString();
}
// mutable definitions
public CustomOrderDefinition custom_order() => OrderDataHelper.Defaults.CustomOrderDefinition();
public MarketOrderDefinition market_order() => OrderDataHelper.Defaults.MarketOrderDefinition();
public LimitOrderDefinition limit_order() => OrderDataHelper.Defaults.LimitOrderDefinition();
public StopOrderDefinition stop_order() => OrderDataHelper.Defaults.StopOrderDefinition();
public StopLimitOrderDefinition stop_limit_order() => OrderDataHelper.Defaults.StopLimitOrderDefinition();
public GLBXIcebergOrderDefinition glbx_iceberg_order() => OrderDataHelper.Defaults.GLBXIcebergOrderDefinition();
public IcebergOrderDefinition iceberg_order() => OrderDataHelper.Defaults.IcebergOrderDefinition();
public TimeBoxOrderDefinition time_box_order() => OrderDataHelper.Defaults.TimeBoxOrderDefinition();
public TickOrderDefinition tick_order() => OrderDataHelper.Defaults.TickOrderDefinition();
public LeanOrderDefinition lean_order() => OrderDataHelper.Defaults.LeanOrderDefinition();
public JoinOrderDefinition join_order() => OrderDataHelper.Defaults.JoinOrderDefinition();
public TopOrderDefinition top_order() => OrderDataHelper.Defaults.TopOrderDefinition();
public CoverOrderDefinition cover_order() => OrderDataHelper.Defaults.CoverOrderDefinition();
public OCOOrderDefinition oco_order() => OrderDataHelper.Defaults.OCOOrderDefinition();
public PricerOrderDefinition pricer_order() => OrderDataHelper.Defaults.PricerOrderDefinition();
public OffsetOrderDefinition offset_order() => OrderDataHelper.Defaults.OffsetOrderDefinition();
public TriggerOrderDefinition trigger_order() => OrderDataHelper.Defaults.TriggerOrderDefinition();
public DynamicOrderDefinition dynamic_order() => OrderDataHelper.Defaults.DynamicOrderDefinition();
public SpreaderOrderDefinition spreader_order() => OrderDataHelper.Defaults.SpreaderOrderDefinition();
public SplitterOrderDefinition splitter_order() => OrderDataHelper.Defaults.SplitterOrderDefinition();
public SpreaderOrderDefinition spreader_order(SecurityImmutable security, ExecutionStrategyImmutable strategy) =>
new SpreaderOrderDefinition {
Security = security.CloneToMutable(),
ExecutionStrategy = strategy.CloneToMutable()
};
// immutable definitions
public CustomOrderDefinitionImmutable custom_orderi(CustomOrderDefinition.CustomOneofCase order_type) => new CustomOrderDefinitionImmutable(custom_order(order_type));
public SpreaderOrderDefinitionImmutable spreader_orderi(SecurityImmutable security, ExecutionStrategyImmutable strategy) => new SpreaderOrderDefinitionImmutable(spreader_order(security, strategy));
public CustomOrderDefinition custom_order(CustomOrderDefinition.CustomOneofCase order_type) {
var rv = new CustomOrderDefinition();
switch (order_type) {
case CustomOrderDefinition.CustomOneofCase.Market: rv.Market = market_order(); break;
case CustomOrderDefinition.CustomOneofCase.Limit: rv.Limit = limit_order(); break;
case CustomOrderDefinition.CustomOneofCase.Stop: rv.Stop = stop_order(); break;
case CustomOrderDefinition.CustomOneofCase.StopLimit: rv.StopLimit = stop_limit_order(); break;
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: rv.GlbxIceberg = glbx_iceberg_order(); break;
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.Cover: rv.Cover = cover_order(); break;
case CustomOrderDefinition.CustomOneofCase.Oco: rv.Oco = oco_order(); break;
case CustomOrderDefinition.CustomOneofCase.Pricer: rv.Pricer = pricer_order(); break;
case CustomOrderDefinition.CustomOneofCase.Offset: rv.Offset = offset_order(); break;
case CustomOrderDefinition.CustomOneofCase.Trigger: rv.Trigger = trigger_order(); break;
case CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = spreader_order(); break;
case CustomOrderDefinition.CustomOneofCase.Splitter: rv.Splitter = splitter_order(); break;
case CustomOrderDefinition.CustomOneofCase.Dynamic: rv.Dynamic = dynamic_order(); break;
//case CustomOrderDefinition.CustomOneofCase.QueueHolder: rv.QueueHolder = queue_holder_order(); break;
default:
OrderTypeVMFactory.GenericOrderFactory.setup_generic_custom_order(rv, order_type);
break;
}
return rv;
}
public OrderMetadata get_metadata(IMessage order_type_def) => get_metadata(OrderDataHelper.get_order_type(order_type_def));
public OrderMetadata get_metadata(OrderRecordImmutable order) => get_metadata(order.Def.CustomDef.CustomCase);
public OrderMetadata get_metadata(CustomOrderDefinition.CustomOneofCase order_type) {
switch (order_type) {
case CustomOrderDefinition.CustomOneofCase.Market: return new OrderMetadata { KeyBinding = "M", Color = BTSColors.yellow.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.Limit: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.green.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.Stop: return new OrderMetadata { KeyBinding = "S", Color = BTSColors.red_orange.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: return new OrderMetadata { KeyBinding = "GB", Color = BTSColors.Orders.glbx_iceberg_order };
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.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.Cover: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.cover_order };
case CustomOrderDefinition.CustomOneofCase.Oco: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.oco_order };
case CustomOrderDefinition.CustomOneofCase.Pricer: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.pricer_order };
case CustomOrderDefinition.CustomOneofCase.Offset: return new OrderMetadata { KeyBinding = "O", Color = BTSColors.Orders.off_order };
case CustomOrderDefinition.CustomOneofCase.Trigger: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.trigger_order };
case CustomOrderDefinition.CustomOneofCase.Spreader: return new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.spreader_order };
// case CustomOrderDefinition.CustomOneofCase.Splitter: return new OrderMetadata { KeyBinding = "", Color = BTSColors.orange.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.Dynamic: return new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.top_order };
case CustomOrderDefinition.CustomOneofCase.None: goto default;
//case CustomOrderDefinition.CustomOneofCase.QueueHolder: return new OrderMetadata { KeyBinding = "Q", Color = BTSColors.purple.rgb_color() };
default: return _default_order_metadata;
}
}
public void Dispose() =>
Disposable.dispose(ref _dispose);
static OneOf<CustomOrderDefinition.CustomOneofCase, string> _simple_algo_id(CustomOrderDefinitionImmutable defi) {
switch (defi.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Dynamic:
return new OneOf<CustomOrderDefinition.CustomOneofCase, string>(defi.Dynamic.DynamicOrderType);
default: return new OneOf<CustomOrderDefinition.CustomOneofCase, string>(defi.CustomCase);
}
}
}
static class OrderDataHelper {
class AlgoTypeCaseDescriptorData {
public readonly IReadOnlyList<ChildAlgoData> child_algo_data;
public readonly IReadOnlyList<FieldDescriptor> value_descriptors;
public readonly FieldDescriptor type_case_descriptor;
public AlgoTypeCaseDescriptorData(FieldDescriptor type_case_descriptor, IReadOnlyList<ChildAlgoData> child_algo_data, IReadOnlyList<FieldDescriptor> value_descriptors) {
this.type_case_descriptor = type_case_descriptor;
this.child_algo_data = child_algo_data;
this.value_descriptors = value_descriptors;
}
}
public static OneofDescriptor oneof_descriptor => _oneof_desc;
const double _price_error_margin = 0.0000001;
const decimal _price_error_margin_decimal = 0.0000001m;
public static readonly IComparer<double> PriceComparer = Comparer<double>.Create((a, b) => {
if (double.IsNaN(a)) {
return double.IsNaN(b) ? 0 : -1;
} else if (double.IsNaN(b)) {
return 1;
} else {
double diff = a - b;
if (diff <= _price_error_margin && diff >= -_price_error_margin)
return 0;
return diff > 0 ? 1 : -1;
}
});
public static readonly IComparer<decimal> PriceComparerDecimal = Comparer<decimal>.Create((a, b) => {
decimal diff = a - b;
if (diff <= _price_error_margin_decimal && diff >= -_price_error_margin_decimal)
return 0;
return diff > 0 ? 1 : -1;
});
const string _primary_child_field = "child";
// 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");
static readonly IReadOnlyDictionary<System.Type, CustomOrderDefinition.CustomOneofCase> _algo_type_case_index;
static readonly IReadOnlyDictionary<CustomOrderDefinition.CustomOneofCase, AlgoTypeCaseDescriptorData> _algo_type_case_descriptor_data;
//
static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.default_order };
static OrderDataHelper() {
var algo_type_case_index = new Dictionary<System.Type, CustomOrderDefinition.CustomOneofCase>();
var algo_type_case_descriptor_data = new Dictionary<CustomOrderDefinition.CustomOneofCase, AlgoTypeCaseDescriptorData>();
var child_algo_index = new Dictionary<CustomOrderDefinition.CustomOneofCase, IReadOnlyList<ChildAlgoData>>();
foreach (var fd in _oneof_desc.Fields) {
var type_case = EnumHelper.parse<CustomOrderDefinition.CustomOneofCase>(fd.Name.Replace("_", ""));
algo_type_case_index.Add(fd.MessageType.ClrType, type_case);
var child_algo_data = new List<ChildAlgoData>(0);
var value_descriptors = new List<FieldDescriptor>(0);
foreach (var f in fd.MessageType.Fields.InDeclarationOrder()) {
if (is_child_algo_field(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) => {
if (fd.Accessor.GetValue(def) is IMessage m)
f.Accessor.SetValue(m, child);
}));
} else {
value_descriptors.Add(f);
}
}
algo_type_case_descriptor_data.Add(type_case, new AlgoTypeCaseDescriptorData(fd, child_algo_data, value_descriptors));
}
_algo_type_case_index = algo_type_case_index;
_algo_type_case_descriptor_data = algo_type_case_descriptor_data;
// local methods
bool is_child_algo_field(FieldDescriptor f) =>
f.FieldType == FieldType.Message && f.MessageType.ClrType == typeof(CustomOrderDefinition);
}
#region Algo Structure/Hierarchy
public static IEnumerable<(CustomOrderDefinition.CustomOneofCase type, string dyn, uint studio, uint spreader_sec)> enumerate_algo_structure(CustomOrderDefinitionImmutable custom_defi) {
string dyn = null;
uint studio = 0, spreader_sec = 0;
foreach (var cd in enumerate_algo_hierarchy(custom_defi.CloneToMutable())) {
switch (cd.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Composite: studio = cd.Composite.AlgoTemplateKey; break;
case CustomOrderDefinition.CustomOneofCase.Dynamic: dyn = cd.Dynamic.DynamicOrderType; break;
case CustomOrderDefinition.CustomOneofCase.Spreader: spreader_sec = cd.Spreader.Security.Id; break;
}
yield return (cd.CustomCase, dyn, studio, spreader_sec);
}
}
/// <summary>
/// Enumerates through every algo member immediately defined <paramref name="custom_def"/> (i.e., no recursion, just the first level of children).
/// </summary>
/// <param name="custom_defi">The root algo, from which enumeration begins.</param>
/// <returns>An IEnumerable of each algo member contained in <paramref name="custom_def"/></returns>
public static IEnumerable<CustomOrderDefinition> enumerate_algo_children(CustomOrderDefinition custom_def) {
switch (custom_def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Dynamic:
foreach (var kv in custom_def.Dynamic.OrderParams) {
if (kv.Value.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef)
yield return kv.Value.AsOrderDef ?? new CustomOrderDefinition();
}
break;
default:
var child_algo_data = get_child_algo_data(custom_def);
if (child_algo_data.Count > 0) {
// need to convert to underlying proto type to use the [reflection-based]generated child selectors
for (int i = 0; i < child_algo_data.Count; i++) {
// don't skip undefined children (this normalizes the structure).
// each algo type should always yield the same number of children.
yield return child_algo_data[i].get_child(custom_def) ?? new CustomOrderDefinition();
}
}
break;
}
}
/// <summary>
/// Enumerates through every algo member contained in <paramref name="custom_def"/>, excluding <paramref name="custom_def"/> itself.
/// </summary>
/// <param name="custom_defi">The root algo, from which enumeration begins.</param>
/// <returns>An IEnumerable of each algo member contained in <paramref name="custom_def"/></returns>
public static IEnumerable<CustomOrderDefinition> enumerate_algo_descendents(CustomOrderDefinition custom_def) {
foreach (var child in enumerate_algo_children(custom_def)) {
yield return child;
foreach (var grand_child in enumerate_algo_descendents(child))
yield return grand_child;
}
}
/// <summary>
/// Enumerates through every algo member contained in <paramref name="custom_def"/>, including <paramref name="custom_def"/> itself.
/// </summary>
/// <param name="custom_def">The root algo, from which enumeration begins.</param>
/// <returns>An IEnumerable of each algo member contained in <paramref name="custom_def"/></returns>
public static IEnumerable<CustomOrderDefinition> enumerate_algo_hierarchy(CustomOrderDefinition custom_def) {
yield return custom_def;
foreach (var d in enumerate_algo_descendents(custom_def))
yield return d;
}
public static IReadOnlyList<ChildAlgoData> get_child_algo_data(CustomOrderDefinitionImmutable defi) =>
get_child_algo_data(defi.CloneToMutable());
public static IReadOnlyList<ChildAlgoData> 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 =>
def is DynamicOrderDefinition dyn &&
dyn.OrderParams.TryGetValue(kv.Key, out var p) &&
p.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef ?
p.AsOrderDef : 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 ChildAlgoData? get_primary_child_algo_data(CustomOrderDefinition algo) {
var child_data = get_child_algo_data(algo);
return child_data.TryGetFirst(cad => cad.name == _primary_child_field, out ChildAlgoData best_match) ? best_match :
child_data.TryGetFirst(out best_match) ? best_match : (ChildAlgoData?)null;
}
public static CustomOrderDefinition create_algo(CustomOrderDefinition.CustomOneofCase algo_type) {
var algo = new CustomOrderDefinition();
if (_algo_type_case_descriptor_data.TryGetValue(algo_type, out AlgoTypeCaseDescriptorData desc))
desc.type_case_descriptor.Accessor.SetValue(algo, ProtoHelper.mutable_factory(ProtoHelper.get_field_type(desc.type_case_descriptor)));
return algo;
}
public static bool append_algo_node(CustomOrderDefinition target, CustomOrderDefinition.CustomOneofCase algo_type) {
if (_algo_type_case_descriptor_data.TryGetValue(algo_type, out var desc)) {
var node = ProtoHelper.mutable_factory(ProtoHelper.get_field_type(desc.type_case_descriptor));
desc.type_case_descriptor.Accessor.SetValue(target, node);
return true;
}
return false;
}
public static IReadOnlyList<ChildAlgoData> 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<ChildAlgoData>();
#endregion
public static OrderMetadata get_metadata(CustomOrderDefinition.CustomOneofCase order_type) {
switch (order_type) {
case CustomOrderDefinition.CustomOneofCase.Market: return new OrderMetadata { KeyBinding = "M", Color = BTSColors.yellow.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.Limit: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.green.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.Stop: return new OrderMetadata { KeyBinding = "S", Color = BTSColors.red_orange.rgb_color(), NoProps = true };
case CustomOrderDefinition.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() };
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: return new OrderMetadata { KeyBinding = "GB", Color = BTSColors.Orders.glbx_iceberg_order };
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.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.Cover: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.cover_order };
case CustomOrderDefinition.CustomOneofCase.Oco: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.oco_order };
case CustomOrderDefinition.CustomOneofCase.Pricer: return new OrderMetadata { KeyBinding = "C", Color = BTSColors.Orders.pricer_order };
case CustomOrderDefinition.CustomOneofCase.Offset: return new OrderMetadata { KeyBinding = "O", Color = BTSColors.Orders.off_order };
case CustomOrderDefinition.CustomOneofCase.Trigger: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.trigger_order };
case CustomOrderDefinition.CustomOneofCase.Spreader: return new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.spreader_order };
case CustomOrderDefinition.CustomOneofCase.Dynamic: return new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.top_order };
case CustomOrderDefinition.CustomOneofCase.None:
default: return _default_order_metadata;
}
}
public static string abbreviate_algo_type(CustomOrderDefinition.CustomOneofCase algo_type) {
switch (algo_type) {
case CustomOrderDefinition.CustomOneofCase.Limit: return "LM";
case CustomOrderDefinition.CustomOneofCase.Cover: return "CV";
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: return "GB";
case CustomOrderDefinition.CustomOneofCase.Iceberg: return "IB";
case CustomOrderDefinition.CustomOneofCase.Lean: return "LN";
case CustomOrderDefinition.CustomOneofCase.Market: return "MA";
case CustomOrderDefinition.CustomOneofCase.Oco: return "OC";
case CustomOrderDefinition.CustomOneofCase.Offset: return "OF";
case CustomOrderDefinition.CustomOneofCase.Pricer: return "PR";
case CustomOrderDefinition.CustomOneofCase.Stop: return "SP";
case CustomOrderDefinition.CustomOneofCase.StopLimit: return "SL";
case CustomOrderDefinition.CustomOneofCase.Tick: return "TI";
case CustomOrderDefinition.CustomOneofCase.TimeBox: return "TB";
case CustomOrderDefinition.CustomOneofCase.Top: return "TP";
case CustomOrderDefinition.CustomOneofCase.Trigger: return "TG";
case CustomOrderDefinition.CustomOneofCase.Join: return "JN";
case CustomOrderDefinition.CustomOneofCase.Spreader: return "SR";
case CustomOrderDefinition.CustomOneofCase.Composite: return "COMP";
default: return algo_type.ToString();
}
}
public static AlgoFormats get_algo_format(Security.ContractOneofCase? security_type) =>
security_type.HasValue ? get_algo_format(security_type.Value) : AlgoFormats.Exchange;
public static AlgoFormats get_algo_format(Security.ContractOneofCase security_type) =>
security_type == Security.ContractOneofCase.Synthetic ? AlgoFormats.Spreader : AlgoFormats.Exchange;
public static HashSet<CustomOrderDefinition.CustomOneofCase> get_format_algo_types(AlgoFormats f) {
var rv = new HashSet<CustomOrderDefinition.CustomOneofCase>();
if ((f & AlgoFormats.Exchange) == AlgoFormats.Exchange) {
rv.AddRange(exchange_order_types);
if ((f & AlgoFormats.Spreader) == AlgoFormats.Spreader) {
rv.IntersectWith(spreader_order_types);
}
} else if ((f & AlgoFormats.Spreader) == AlgoFormats.Spreader) {
rv.AddRange(spreader_order_types);
}
if ((f & AlgoFormats.Attachable) == AlgoFormats.Attachable)
rv.AddRange(attachable_order_types);
if ((f & AlgoFormats.DefaultPlaceholder) == AlgoFormats.DefaultPlaceholder)
rv.Add(CustomOrderDefinition.CustomOneofCase.None);
return rv;
}
public static CustomOrderDefinition.CustomOneofCase get_default_algo(AlgoFormats f) {
switch (f) {
case AlgoFormats.Exchange: return CustomOrderDefinition.CustomOneofCase.Limit;
case AlgoFormats.Spreader: return CustomOrderDefinition.CustomOneofCase.Spreader;
default: return CustomOrderDefinition.CustomOneofCase.None;
}
}
public static IReadOnlyDictionary<AlgoKey, AlgoData> get_format_algo_data(AlgoFormats f) {
var algo_types = get_format_algo_types(f);
var algo_dict = algo_types.Select(at => AlgoData.from_custom_def(Defaults.CustomOrderDefinitionImmutable(at))).ToDictionaryCrushed(a => a.key);
return algo_dict;
}
public static HashSet<CustomOrderDefinition.CustomOneofCase> get_algo_types_present(CustomOrderDefinitionImmutable def) {
return new HashSet<CustomOrderDefinition.CustomOneofCase>(impl(def.CloneToMutable()));
// hide mutable-def implementation
IEnumerable<CustomOrderDefinition.CustomOneofCase> impl(CustomOrderDefinition mdef) {
yield return mdef.CustomCase;
foreach (var sd in get_child_algo_data(mdef)) {
var child = sd.get_child(mdef);
if (child != null) {
yield return child.CustomCase;
foreach (var t in impl(child))
yield return t;
}
}
}
}
public static CustomOrderDefinitionImmutable? fit_to_type(CustomOrderDefinitionImmutable defi, Security.ContractOneofCase security_type, bool fit_all_to_spreader = false) {
var mdef = defi.CloneToMutable();
switch (security_type) {
case Security.ContractOneofCase.Synthetic:
mdef = spreader_impl(mdef);
break;
default:
mdef = outright_impl(mdef);
break;
}
if (mdef == null)
return null;
return new CustomOrderDefinitionImmutable(mdef);
// local methods
CustomOrderDefinition spreader_impl(CustomOrderDefinition def) {
if (def == null) {
def = new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() };
} else {
switch (def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Limit:
case CustomOrderDefinition.CustomOneofCase.None:
def = new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() };
break;
case CustomOrderDefinition.CustomOneofCase.Stop:
case CustomOrderDefinition.CustomOneofCase.StopLimit:
case CustomOrderDefinition.CustomOneofCase.Market:
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg:
def = fit_all_to_spreader ? new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() } : null;
break;
default:
var desc_data = _algo_type_case_descriptor_data[def.CustomCase];
foreach (var cad in desc_data.child_algo_data) {
var child = spreader_impl(cad.get_child(def));
if (child == null)
return null;
var type_def = (IMessage)desc_data.type_case_descriptor.Accessor.GetValue(def);
cad.assign_child_to_impl(type_def, child);
}
break;
}
}
return def;
}
CustomOrderDefinition outright_impl(CustomOrderDefinition def) {
if (def == null) {
def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() };
} else {
switch (def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Spreader:
case CustomOrderDefinition.CustomOneofCase.None:
def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() };
break;
default:
foreach (var cad in get_child_algo_data(def)) {
var child = outright_impl(cad.get_child(def));
if (child == null)
return null;
cad.assign_child(def, child);
}
break;
}
}
return def;
}
}
public static readonly CustomOrderDefinition.CustomOneofCase[]
// exchange_order_types are the types which can be submitted on an exchange security
exchange_order_types = new[] {
CustomOrderDefinition.CustomOneofCase.Market,
CustomOrderDefinition.CustomOneofCase.Limit,
CustomOrderDefinition.CustomOneofCase.Stop,
CustomOrderDefinition.CustomOneofCase.StopLimit,
CustomOrderDefinition.CustomOneofCase.GlbxIceberg,
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.Lean,
CustomOrderDefinition.CustomOneofCase.Join,
CustomOrderDefinition.CustomOneofCase.Cover,
CustomOrderDefinition.CustomOneofCase.Top,
CustomOrderDefinition.CustomOneofCase.Offset,
CustomOrderDefinition.CustomOneofCase.Splitter,
CustomOrderDefinition.CustomOneofCase.Scratch,
CustomOrderDefinition.CustomOneofCase.Prorata,
},
spreader_order_types = new[] {
CustomOrderDefinition.CustomOneofCase.Spreader,
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.Lean,
CustomOrderDefinition.CustomOneofCase.Join,
CustomOrderDefinition.CustomOneofCase.Cover,
CustomOrderDefinition.CustomOneofCase.Top,
CustomOrderDefinition.CustomOneofCase.Splitter,
CustomOrderDefinition.CustomOneofCase.Scratch,
CustomOrderDefinition.CustomOneofCase.Prorata,
},
attachable_order_types = new[] {
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.Lean,
CustomOrderDefinition.CustomOneofCase.Join,
CustomOrderDefinition.CustomOneofCase.Cover,
CustomOrderDefinition.CustomOneofCase.Top,
CustomOrderDefinition.CustomOneofCase.Offset,
CustomOrderDefinition.CustomOneofCase.Scratch,
CustomOrderDefinition.CustomOneofCase.Prorata,
},
outright_order_types = new[] {
CustomOrderDefinition.CustomOneofCase.Market,
CustomOrderDefinition.CustomOneofCase.Limit,
CustomOrderDefinition.CustomOneofCase.Stop,
CustomOrderDefinition.CustomOneofCase.StopLimit,
CustomOrderDefinition.CustomOneofCase.GlbxIceberg,
};
public static readonly CustomOrderDefinition.CustomOneofCase[] all_order_types = exchange_order_types.Union(spreader_order_types).ToArray();
public static void copy_values(CustomOrderDefinitionImmutable source, ref CustomOrderDefinition target) =>
copy_values(source.CloneToMutable(), ref target);
public static void copy_values(CustomOrderDefinition source, ref CustomOrderDefinition target) {
if (source == null || target == null || source.CustomCase != target.CustomCase)
return;
var desc_data = _algo_type_case_descriptor_data[source.CustomCase];
var src_type_def = desc_data.type_case_descriptor.Accessor.GetValue(source) as IMessage;
var tgt_type_def = desc_data.type_case_descriptor.Accessor.GetValue(target) as IMessage;
foreach (var fd in desc_data.value_descriptors) {
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.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);
}
}
public static CustomOrderDefinition.CustomOneofCase get_order_type(IMessage order_type_def) =>
order_type_def != null && _algo_type_case_index.TryGetValue(order_type_def.Descriptor.ClrType, out CustomOrderDefinition.CustomOneofCase algo_case) ?
algo_case : CustomOrderDefinition.CustomOneofCase.None;
#region Private Members
// get child
static CustomOrderDefinitionImmutable? _get_iceberg_child(IcebergOrderDefinitionImmutable iceberg) => iceberg.HasChild ? iceberg.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_time_box_child(TimeBoxOrderDefinitionImmutable time_box) => time_box.HasChild ? time_box.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_tick_child(TickOrderDefinitionImmutable tick) => tick.HasChild ? tick.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_lean_child(LeanOrderDefinitionImmutable lean) => lean.HasChild ? lean.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_join_child(JoinOrderDefinitionImmutable join) => join.HasChild ? join.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_top_child(TopOrderDefinitionImmutable top) => top.HasChild ? top.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_cover_child(CoverOrderDefinitionImmutable cover) => cover.HasChild ? cover.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_oco_child(OCOOrderDefinitionImmutable oco) => oco.HasChild ? oco.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_pricer_child(PricerOrderDefinitionImmutable pricer) => pricer.HasChild ? pricer.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_offset_child(OffsetOrderDefinitionImmutable offset) => offset.HasChild ? offset.Child : (CustomOrderDefinitionImmutable?)null;
static CustomOrderDefinitionImmutable? _get_trigger_child(TriggerOrderDefinitionImmutable trigger) => trigger.HasChild ? trigger.Child : (CustomOrderDefinitionImmutable?)null;
// get hedge
static CustomOrderDefinitionImmutable? _get_cover_hedge(CoverOrderDefinitionImmutable cover) => cover.HasHedge ? cover.Hedge : (CustomOrderDefinitionImmutable?)null;
// assign hedge
static void _assign_cover_hedge(ref CoverOrderDefinition cover, CustomOrderDefinition child) => cover.Child = child;
// get other
static CustomOrderDefinitionImmutable? _get_oco_stop(OCOOrderDefinitionImmutable oco) => oco.HasOther ? oco.Other : (CustomOrderDefinitionImmutable?)null;
// assign other
static void _assign_oco_hedge(ref OCOOrderDefinition oco, CustomOrderDefinition other) => oco.Other = other;
#endregion
public static class EqualsHelpers {
// Unfortunately, the generated Equals method compares doubles with the '==' operator.
// That causes problems in some usages (e.g., AlgoStudio, and the Ladder/Ticket algo popup), bc double.NaN != double.NaN.
// These equality comparers should be user in such cases, as they use the actual double.Equals method, not the == operator.
// https://github.com/protocolbuffers/protobuf/issues/3725
public static readonly IEqualityComparer<CustomOrderDefinitionImmutable>
custom_order_defi_comparer = new CustomDefinitionComparer(),
custom_order_defi_structure_comparer = new CustomDefinitionStructureComparer();
public static bool equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) => custom_order_defi_comparer.Equals(a, b);
public static bool structure_equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) {
return impl(a.CloneToMutable(), b.CloneToMutable());
bool impl(CustomOrderDefinition ma, CustomOrderDefinition 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) =>
a.ShowQuantity.Equals(b.ShowQuantity) && a.HasChild ? b.HasChild && equals(a.Child, b.Child) : !b.HasChild;
public static bool join_equals(JoinOrderDefinitionImmutable a, JoinOrderDefinitionImmutable b) =>
(a.HasJoinThreshold ?
b.HasJoinThreshold && quantity_measure_equals(a.JoinThreshold, b.JoinThreshold) :
!b.HasJoinThreshold) &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild);
public static bool top_equals(TopOrderDefinitionImmutable a, TopOrderDefinitionImmutable b) =>
a.TicksOff == b.TicksOff &&
(a.HasTopThreshold ?
b.HasTopThreshold && quantity_measure_equals(a.TopThreshold, b.TopThreshold) :
!b.HasTopThreshold) &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild);
public static bool lean_equals(LeanOrderDefinitionImmutable a, LeanOrderDefinitionImmutable b) =>
a.MaxChaseTicks == b.MaxChaseTicks &&
a.TradeTowardBehavior == b.TradeTowardBehavior &&
(a.HasCrossThreshold ?
b.HasCrossThreshold && quantity_measure_equals(a.CrossThreshold, b.CrossThreshold) :
!b.HasCrossThreshold) &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild);
public static bool stop_limit_equals(StopLimitOrderDefinitionImmutable a, StopLimitOrderDefinitionImmutable b) =>
a.StopPrice.Equals(b.StopPrice);
public static bool cover_equals(CoverOrderDefinitionImmutable a, CoverOrderDefinitionImmutable b) =>
a.HedgeTicks == b.HedgeTicks &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild) &&
(a.HasHedge ?
b.HasHedge && equals(a.Hedge, b.Hedge) :
!b.HasHedge);
public static bool oco_equals(OCOOrderDefinitionImmutable a, OCOOrderDefinitionImmutable b) =>
a.OtherTicks == b.OtherTicks &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild) &&
(a.HasOther ?
b.HasOther && equals(a.Other, b.Other) :
!b.HasOther);
public static bool pricer_equals(PricerOrderDefinitionImmutable a, PricerOrderDefinitionImmutable b) =>
a.PriceFactor.Equals(b.PriceFactor) && a.HasChild ? b.HasChild && equals(a.Child, b.Child) : !b.HasChild;
public static bool tick_equals(TickOrderDefinitionImmutable a, TickOrderDefinitionImmutable b) =>
a.MaxChaseTicks == b.MaxChaseTicks &&
a.TickOffsetOnDeploy == b.TickOffsetOnDeploy &&
a.DetachOnToward == b.DetachOnToward &&
(a.HasCrossThreshold ?
b.HasCrossThreshold && quantity_measure_equals(a.CrossThreshold, b.CrossThreshold) :
!b.HasCrossThreshold) &&
(a.HasChild ?
b.HasChild && equals(a.Child, b.Child) :
!b.HasChild);
public static bool trigger_equals(TriggerOrderDefinitionImmutable a, TriggerOrderDefinitionImmutable b) {
// TriggerAction
if (a.HasTriggerAction) {
if (!b.HasTriggerAction || !trigger_action_equals(a.TriggerAction, b.TriggerAction))
return false;
} else if (b.HasTriggerAction)
return false;
// ExitCondition
if (a.HasExitCondition) {
if (!b.HasExitCondition || !trigger_exit_condition_equals(a.ExitCondition, b.ExitCondition))
return false;
} else if (b.HasExitCondition)
return false;
if (a.HasTriggerCondition) {
if (!b.HasTriggerCondition || !trigger_condition_equals(a.TriggerCondition, b.TriggerCondition))
return false;
} else if (b.HasTriggerCondition)
return false;
return a.HasChild ? b.HasChild && equals(a.Child, b.Child) : !b.HasChild;
}
public static bool trigger_action_equals(TriggerActionImmutable a, TriggerActionImmutable b) {
if (a.OrderpriceCase != b.OrderpriceCase)
return false;
if (a.HasPayup) {
if (!b.HasPayup || !trigger_payup_price_equals(a.Payup, b.Payup))
return false;
} else if (b.HasPayup) {
return false;
}
if (!a.Price.Equals(b.Price))
return false;
return true;
}
public static bool trigger_condition_equals(TriggerConditionImmutable a, TriggerConditionImmutable b) {
if (a.TriggerCase != b.TriggerCase || a.PriceType != b.PriceType)
return false;
switch (a.TriggerCase) {
case TriggerCondition.TriggerOneofCase.AbsolutePriceTrigger: return absolute_price_trigger_equals(a.AbsolutePriceTrigger, b.AbsolutePriceTrigger);
case TriggerCondition.TriggerOneofCase.TrailingTrigger: return trailing_trigger_equals(a.TrailingTrigger, b.TrailingTrigger);
case TriggerCondition.TriggerOneofCase.None: return true;
default: throw ExceptionBuilder.Argument.unexpected_case(a.TriggerCase, "TriggerCase");
}
}
public static bool trailing_trigger_equals(bts.api.orderman.TrailingTriggerImmutable a, bts.api.orderman.TrailingTriggerImmutable b) =>
a.TriggerType == b.TriggerType && a.NumberOfTicks == b.NumberOfTicks;
public static bool trigger_payup_price_equals(TriggerPayupPriceImmutable a, TriggerPayupPriceImmutable b) =>
a.PayupPriceType == b.PayupPriceType && a.PriceType == b.PriceType && a.PayupTicks == b.PayupTicks;
public static bool trigger_exit_condition_equals(TriggerExitConditionImmutable a, TriggerExitConditionImmutable b) =>
a.TimeoutEnabled == b.TimeoutEnabled && a.TimeoutSeconds == b.TimeoutSeconds;
public static bool absolute_price_trigger_equals(bts.api.orderman.AbsolutePriceTriggerImmutable a, bts.api.orderman.AbsolutePriceTriggerImmutable b) =>
a.HasTriggerQuantity ? b.HasTriggerQuantity && trigger_quantity_equals(a.TriggerQuantity, b.TriggerQuantity) : !b.HasTriggerQuantity;
public static bool trigger_quantity_equals(TriggerQuantityImmutable a, TriggerQuantityImmutable b) =>
a.HasQuantityMeasure ? b.HasQuantityMeasure && quantity_measure_equals(a.QuantityMeasure, b.QuantityMeasure) : !b.HasQuantityMeasure;
public static bool quantity_measure_equals(QuantityMeasureImmutable a, QuantityMeasureImmutable b) {
if (a.QuantityCase != b.QuantityCase)
return false;
switch (a.QuantityCase) {
case QuantityMeasure.QuantityOneofCase.Absolute: return a.Absolute == b.Absolute;
case QuantityMeasure.QuantityOneofCase.Ratio: return a.Ratio.Equals(b.Ratio);
case QuantityMeasure.QuantityOneofCase.None: return true;
default: throw ExceptionBuilder.Argument.unexpected_case(a.QuantityCase, "QuantityCase");
}
}
class CustomDefinitionComparer : IEqualityComparer<CustomOrderDefinitionImmutable> {
public bool Equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) {
if (a.CustomCase != b.CustomCase) return false;
switch (a.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Cover: return cover_equals(a.Cover, b.Cover);
case CustomOrderDefinition.CustomOneofCase.Oco: return oco_equals(a.Oco, b.Oco);
case CustomOrderDefinition.CustomOneofCase.Pricer: return pricer_equals(a.Pricer, b.Pricer);
case CustomOrderDefinition.CustomOneofCase.Iceberg: return iceberg_equals(a.Iceberg, b.Iceberg);
case CustomOrderDefinition.CustomOneofCase.Join: return join_equals(a.Join, b.Join);
case CustomOrderDefinition.CustomOneofCase.Lean: return lean_equals(a.Lean, b.Lean);
case CustomOrderDefinition.CustomOneofCase.Limit: return true;
case CustomOrderDefinition.CustomOneofCase.StopLimit: return stop_limit_equals(a.StopLimit, b.StopLimit);
case CustomOrderDefinition.CustomOneofCase.Tick: return tick_equals(a.Tick, b.Tick);
case CustomOrderDefinition.CustomOneofCase.Top: return top_equals(a.Top, b.Top);
case CustomOrderDefinition.CustomOneofCase.Trigger: return trigger_equals(a.Trigger, b.Trigger);
default: return a.Equals(b);
}
}
public int GetHashCode(CustomOrderDefinitionImmutable def) {
int hash = (int)def.CustomCase;
int phase_mult = 1;
switch (def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Cover:
add_component(def.Cover.HedgeTicks.GetHashCode());
add_component(_get_hash(_get_cover_child(def.Cover)));
add_component(_get_hash(_get_cover_hedge(def.Cover)));
break;
case CustomOrderDefinition.CustomOneofCase.Oco:
add_component(def.Oco.OtherTicks);
add_component(_get_hash(_get_oco_child(def.Oco)));
add_component(_get_hash(_get_oco_stop(def.Oco)));
break;
case CustomOrderDefinition.CustomOneofCase.Pricer:
add_component(def.Pricer.PriceFactor.GetHashCode());
add_component(_get_hash(_get_pricer_child(def.Pricer)));
break;
case CustomOrderDefinition.CustomOneofCase.Iceberg:
add_component(def.Iceberg.ShowQuantity.GetHashCode());
add_component(_get_hash(_get_iceberg_child(def.Iceberg)));
break;
case CustomOrderDefinition.CustomOneofCase.Join:
add_component(def.Join.HasJoinThreshold ? def.Join.JoinThreshold.GetHashCode() : 0);
add_component(_get_hash(_get_join_child(def.Join)));
break;
case CustomOrderDefinition.CustomOneofCase.Lean:
add_component(def.Lean.HasCrossThreshold ? def.Lean.CrossThreshold.GetHashCode() : 0);
add_component(_get_hash(_get_lean_child(def.Lean)));
break;
case CustomOrderDefinition.CustomOneofCase.StopLimit:
add_component(def.StopLimit.StopPrice.GetHashCode());
break;
case CustomOrderDefinition.CustomOneofCase.Tick:
var tick = def.Tick;
add_component(tick.CrossTicks.GetHashCode());
add_component(tick.MaxChaseTicks.GetHashCode());
add_component(tick.TickOffsetOnDeploy.GetHashCode());
add_component(tick.DetachOnToward.GetHashCode());
add_component(tick.HasCrossThreshold ? def.Tick.CrossThreshold.GetHashCode() : 0);
add_component(_get_hash(_get_tick_child(tick)));
break;
case CustomOrderDefinition.CustomOneofCase.Top:
add_component(def.Top.TicksOff.GetHashCode());
add_component(def.Top.HasTopThreshold ? def.Top.TopThreshold.GetHashCode() : 0);
add_component(_get_top_child(def.Top).GetHashCode());
break;
case CustomOrderDefinition.CustomOneofCase.Trigger:
var trigger = def.Trigger;
add_component(trigger.HasExitCondition ? def.Trigger.ExitCondition.GetHashCode() : 0);
add_component(trigger.HasTriggerAction ? def.Trigger.TriggerAction.GetHashCode() : 0);
add_component(trigger.HasTriggerCondition ? def.Trigger.TriggerCondition.GetHashCode() : 0);
add_component(_get_hash(_get_trigger_child(trigger)));
break;
case CustomOrderDefinition.CustomOneofCase.Offset:
add_component(def.Offset.TickOffsetOnDeploy.GetHashCode());
add_component(_get_hash(_get_offset_child(def.Offset)));
break;
}
return hash;
void add_component(int component_hash) =>
_add_component(ref hash, ref phase_mult, component_hash);
}
void _add_component(ref int hash, ref int phase_mult, int component_hash) =>
hash += EqualityComparer.phase_hash(component_hash, phase_mult++, MathUtils.Primes.P_1087);
int _get_hash(CustomOrderDefinitionImmutable? a) => a.HasValue ? GetHashCode(a.Value) : 0;
}
class CustomDefinitionStructureComparer : IEqualityComparer<CustomOrderDefinitionImmutable> {
public bool Equals(CustomOrderDefinitionImmutable def1, CustomOrderDefinitionImmutable def2) =>
enumerate_algo_structure(def1).SequenceEqual(enumerate_algo_structure(def2));
public int GetHashCode(CustomOrderDefinitionImmutable def) =>
EqualityComparer.auto_phase(enumerate_algo_structure(def));
}
}
public static class CompareUtils {
public static readonly IEqualityComparer<OrderRecordImmutable> order_record_id_eq_comparer =
EqualityComparer.Create<OrderRecordImmutable, uint>(o => o.Key);
public static readonly IComparer<double> bid_price_comparer =
Comparer<double>.Create((x, y) => MathUtils.epsilon_equals(x, y) ? 0 : y.CompareTo(x));
public static readonly IComparer<double> ask_price_comparer =
Comparer<double>.Create((x, y) => MathUtils.epsilon_equals(x, y) ? 0 : x.CompareTo(y));
}
public static class Defaults {
// param types
public static QuantityMeasure QuantityMeasure => new QuantityMeasure { Absolute = 1 };
// core data types
public static AlgoData AlgoData() => spark.AlgoData.from_custom_def(CustomOrderDefinitionImmutable());
public static AlgoData AlgoData(CustomOrderDefinition.CustomOneofCase algo_type) => spark.AlgoData.from_custom_def(CustomOrderDefinitionImmutable(algo_type));
public static OrderDefinition OrderDefinition => new OrderDefinition { CustomDef = new CustomOrderDefinition() };
public static OrderRecord OrderRecord => new OrderRecord {
Def = OrderDefinition,
State = new OrderState {
LastChange = Timestamp.FromDateTime(DateTime.UtcNow)
}
};
public static OrderDefinitionImmutable OrderDefinitionImmutable { get; } = new OrderDefinitionImmutable(OrderDefinition);
public static OrderRecordImmutable OrderRecordImmutable { get; } = new OrderRecordImmutable(OrderRecord);
public static CustomOrderDefinition CustomOrderDefinition() => new CustomOrderDefinition { Limit = LimitOrderDefinition() };
public static CustomOrderDefinition CustomOrderDefinition(CustomOrderDefinition.CustomOneofCase order_type) {
var rv = new CustomOrderDefinition();
switch (order_type) {
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Market: rv.Market = MarketOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Limit: rv.Limit = LimitOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Stop: rv.Stop = StopOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.StopLimit: rv.StopLimit = StopLimitOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Iceberg: rv.Iceberg = IcebergOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.GlbxIceberg: rv.GlbxIceberg = GLBXIcebergOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.TimeBox: rv.TimeBox = TimeBoxOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Tick: rv.Tick = TickOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Lean: rv.Lean = LeanOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Join: rv.Join = JoinOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Top: rv.Top = TopOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Cover: rv.Cover = CoverOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Oco: rv.Oco = OCOOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Pricer: rv.Pricer = PricerOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Offset: rv.Offset = OffsetOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Trigger: rv.Trigger = TriggerOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = SpreaderOrderDefinition(); break;
case bts.api.orderman.CustomOrderDefinition.CustomOneofCase.Dynamic: rv.Dynamic = DynamicOrderDefinition(); break;
default:
OrderTypeVMFactory.GenericOrderFactory.setup_generic_custom_order(rv, order_type);
break;
}
return rv;
}
public static CustomOrderDefinitionImmutable CustomOrderDefinitionImmutable() => new CustomOrderDefinitionImmutable(CustomOrderDefinition());
public static CustomOrderDefinitionImmutable CustomOrderDefinitionImmutable(CustomOrderDefinition.CustomOneofCase order_type) => new CustomOrderDefinitionImmutable(CustomOrderDefinition(order_type));
public static MarketOrderDefinition MarketOrderDefinition() => new MarketOrderDefinition { };
public static LimitOrderDefinition LimitOrderDefinition() => new LimitOrderDefinition { };
public static StopOrderDefinition StopOrderDefinition() => new StopOrderDefinition { };
public static StopLimitOrderDefinition StopLimitOrderDefinition() => new StopLimitOrderDefinition { };
public static GLBXIcebergOrderDefinition GLBXIcebergOrderDefinition() => new GLBXIcebergOrderDefinition { MaxShowQuantity = 1 };
public static IcebergOrderDefinition IcebergOrderDefinition() => new IcebergOrderDefinition { Child = CustomOrderDefinition(), ShowQuantity = 1 };
public static TimeBoxOrderDefinition TimeBoxOrderDefinition() => new TimeBoxOrderDefinition { Child = CustomOrderDefinition(), Start = Timestamp.FromDateTime(DateTime.UtcNow), Stop = Timestamp.FromDateTime(DateTime.UtcNow) };
public static TickOrderDefinition TickOrderDefinition() => new TickOrderDefinition { Child = CustomOrderDefinition(), CrossThreshold = QuantityMeasure };
public static LeanOrderDefinition LeanOrderDefinition() => new LeanOrderDefinition { Child = CustomOrderDefinition(), CrossThreshold = QuantityMeasure, MaxChaseTicks = 2 };
public static JoinOrderDefinition JoinOrderDefinition() => new JoinOrderDefinition { Child = CustomOrderDefinition(), JoinThreshold = QuantityMeasure };
public static TopOrderDefinition TopOrderDefinition() => new TopOrderDefinition { Child = CustomOrderDefinition(), TopThreshold = QuantityMeasure };
public static CoverOrderDefinition CoverOrderDefinition() => new CoverOrderDefinition { Child = CustomOrderDefinition(), Hedge = CustomOrderDefinition(), HedgeTicks = 1 };
public static OCOOrderDefinition OCOOrderDefinition() => new OCOOrderDefinition { Child = CustomOrderDefinition(), Other = CustomOrderDefinition(), OtherSide = RelativeSide.Same };
public static PricerOrderDefinition PricerOrderDefinition() => new PricerOrderDefinition { Child = CustomOrderDefinition() };
public static OffsetOrderDefinition OffsetOrderDefinition() => new OffsetOrderDefinition { Child = CustomOrderDefinition(), };
public static TriggerOrderDefinition TriggerOrderDefinition() => new TriggerOrderDefinition { Child = CustomOrderDefinition(), TriggerCondition = new TriggerCondition(), TriggerAction = new TriggerAction(), };
public static DynamicOrderDefinition DynamicOrderDefinition() => new DynamicOrderDefinition();
public static SpreaderOrderDefinition SpreaderOrderDefinition() => new SpreaderOrderDefinition { ExecutionStrategy = new ExecutionStrategy() };
public static SplitterOrderDefinition SplitterOrderDefinition() => new SplitterOrderDefinition();
}
}
}