1093 lines
69 KiB
C#
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();
|
|
}
|
|
}
|
|
|
|
}
|