Files
spark/src/client/spark_api/security/SecurityHelper.cs
T
2019-03-07 17:56:28 -05:00

117 lines
5.9 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using static bts.api.Security;
namespace bts.api {
internal static class SecurityHelper {
public static IEnumerable<FutureLeg> get_flat_future_legs(SecurityImmutable sec) {
switch (sec.ContractCase) {
case ContractOneofCase.Spread: return _get_flat_future_legs(sec.Spread.Legs, 1);
case ContractOneofCase.Synthetic: return _get_flat_future_legs(sec.Synthetic.Legs, 1);
default: return Enumerable.Empty<FutureLeg>();
}
}
public static IEnumerable<FutureLeg> get_flat_future_legs(IEnumerable<ContractLegImmutable> legs) => _get_flat_future_legs(legs, 1);
static IEnumerable<FutureLeg> _get_flat_future_legs(IEnumerable<ContractLegImmutable> legs, int qty) {
foreach (var l in legs) {
switch (l.Security.ContractCase) {
case ContractOneofCase.Future:
yield return new FutureLeg(l.Security.Exchange, l.Security.Symbol, l.Security.security_desc(), l.Security.Future, qty * l.SignedQuantity());
break;
case ContractOneofCase.Spread:
foreach (var fl in _get_flat_future_legs(l.Security.Spread.Legs, qty * l.SignedQuantity()))
yield return fl;
break;
case ContractOneofCase.Synthetic:
foreach (var fl in _get_flat_future_legs(l.Security.Synthetic.Legs, qty * l.SignedQuantity()))
yield return fl;
break;
}
}
}
#region Extensions
public static DateTime expiration_date(this FutureContract future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); }
public static DateTime expiration_date(this FutureContractImmutable future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); }
internal static DateTime EarliestExpiration(this SecurityImmutable security) {
switch (security.ContractCase) {
case ContractOneofCase.Synthetic: return security.Synthetic.Legs.First().Security.EarliestExpiration();
case ContractOneofCase.Spread: return security.Spread.Legs.First().Security.EarliestExpiration();
case ContractOneofCase.Future: return security.Future.expiration_date();
default: throw new NotImplementedException();
}
}
internal static int SignedQuantity(this ContractLegImmutable leg) => leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity;
internal static int SignedQuantity(this ContractLeg leg) => leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity;
internal static string ForceSymbol(this SecurityImmutable security) {
if (security.ContractCase == ContractOneofCase.Synthetic) return ForceSymbol(security.Synthetic.Legs.First().Security);
else return security.Symbol;
}
public static string DisplayExchange(this SecurityImmutable security) =>
security.ContractCase == ContractOneofCase.Synthetic ? $"[{string.Join(",", get_flat_future_legs(security).Select(flt => flt.exchange.ToString()).Distinct().OrderBy(e => e))}]" : security.Exchange.ToString();
public static string security_desc(this SecurityImmutable security)
{
if(security.HasGlbx)
return security.Glbx.SecurityDesc;
else if(security.HasIce)
return security.Ice.SecurityDesc;
else
{
Log.assert(false, "security_desc not implemented for exchange");
return null;
}
}
#endregion
public static class Comparer {
public static readonly IComparer<Security> Instance = Comparer<Security>.Create(Compare);
public static readonly IComparer<SecurityImmutable> InstanceImmutable = Comparer<SecurityImmutable>.Create(Compare);
public static int Compare(Security x, Security y) {
if (ReferenceEquals(x, y)) return 0; // x ==y
if (x == null) return 1; // y > x
if (y == null) return -1; // x > y
return Compare(new SecurityImmutable(x), new SecurityImmutable(y));
}
public static int Compare(SecurityImmutable x, SecurityImmutable y) {
if (x.ContractCase == ContractOneofCase.Future) return y.ContractCase == ContractOneofCase.Future ? Compare(x.Symbol, x.Future, y.Symbol, y.Future) : -1;
else if (y.ContractCase == ContractOneofCase.Future) return 1;
var xlegs = get_flat_future_legs(x).ToList();
var ylegs = get_flat_future_legs(y).ToList();
int max = Math.Min(xlegs.Count, ylegs.Count);
for (int i = 0; i < max; i++) {
int rv = Compare(xlegs[i].symbol, xlegs[i].future, ylegs[i].symbol, ylegs[i].future);
if (rv != 0) return rv;
}
for (int i = 0; i < max; i++) {
int rv = xlegs[i].quantity.CompareTo(ylegs[i].quantity);
if (rv != 0) return rv;
}
for (int i = 0; i < max; i++) {
int rv = xlegs[i].exchange.CompareTo(ylegs[i].exchange);
if (rv != 0) return rv;
}
return xlegs.Count.CompareTo(ylegs.Count);
}
public static int Compare(string x_sym, FutureContract x, string y_sym, FutureContract y) {
int sym_comp = x_sym.CompareTo(y_sym);
return sym_comp == 0 ? x.expiration_date().CompareTo(y.expiration_date()) : sym_comp;
}
public static int Compare(string x_sym, FutureContractImmutable x, string y_sym, FutureContractImmutable y) {
int sym_comp = x_sym.CompareTo(y_sym);
return sym_comp == 0 ? x.expiration_date().CompareTo(y.expiration_date()) : sym_comp;
}
}
}
}