namespace bts.api { using System; using System.Collections.Concurrent; using System.Collections.Generic; public static class SecurityFormatter { static readonly ConcurrentDictionary _formatted_names_cache = new(); public static string format(Security security) => _formatted_names_cache.GetOrAdd(security.Id, _format(security)); public static string format(SecurityImmutable security) => _formatted_names_cache.GetOrAdd(security.Id, _ => _format(security)); public static string format_contract_legs(IEnumerable legs) { var future_legs = new ContractLegEnumerable(legs, 1); return string.Join("", _format_legs(future_legs)); } public static string format_future(string symbol, DateTime exp) => format_future(symbol, (uint)exp.Year, (uint)exp.Month, (uint)exp.Day); public static string format_future(string symbol, uint exp_year, uint exp_month, uint exp_day) => $"{symbol}{format_expiration(new((int)exp_year, (int)exp_month, (int)exp_day))}"; public static string format_future(string symbol, FutureContractImmutable future) => format_future(symbol, future.ExpirationYear, future.ExpirationMonth, future.ExpirationDay); public static string format_future(string symbol, string exch_desc, FutureContractImmutable future) => string.IsNullOrEmpty(exch_desc) ? format_future(symbol, future) : exch_desc; public static string format_option(string symbol, uint exp_year, uint exp_month, uint exp_day, double strike, PutOrCall call_put) { var cp = call_put switch { PutOrCall.Call => 'C', PutOrCall.Put => 'P', _ => '?' }; return $"{format_future(symbol, exp_year, exp_month, exp_day)} {strike}{cp}"; } public static string format_option(string symbol, OptionContractImmutable option) => format_option(symbol, option.ExpirationYear, option.ExpirationMonth, option.ExpirationDay, option.Strike, option.CallPut); public static string format_option(string symbol, string exch_desc, OptionContractImmutable option) => string.IsNullOrEmpty(exch_desc) ? format_option(symbol, option) : exch_desc; static string _format(SecurityImmutable? security) => security.HasValue ? _format(security.Value) : "Unknown-security1"; static string _format(SecurityImmutable security, bool exchange_specific_formatting = true) { switch (security.ContractCase) { case Security.ContractOneofCase.Future: if (exchange_specific_formatting && security.HasIce) { return ExchangeSpecificUtilities.format_security(security); } return format_future(security.Symbol, security.security_desc(), security.Future); case Security.ContractOneofCase.Option: return format_option(security.Symbol, security.security_desc(), security.Option); case Security.ContractOneofCase.Spread: if (exchange_specific_formatting) { switch (security.ExchangeDataCase) { case Security.ExchangeDataOneofCase.Glbx: return security.Glbx.SecurityDesc; case Security.ExchangeDataOneofCase.Ice: return ExchangeSpecificUtilities.format_security(security); case Security.ExchangeDataOneofCase.Deribit: return security.Deribit.SecurityDesc; } } return string.Join("", _format_legs(new ContractLegEnumerable(security.Spread.Legs, 1))); case Security.ContractOneofCase.Synthetic: return security.Synthetic.Name; case Security.ContractOneofCase.Spot: return security.security_desc(); default: return "Unknown-security2"; } } /// /// Returns a shorthand string representation of a security type appropriate for UIs. /// public static string format_security_type(SecurityType type) => format_security_type(type.contract_case()); public static string format_security_type(Security.ContractOneofCase type) => type switch { Security.ContractOneofCase.Future => "FUT", Security.ContractOneofCase.Option => "OPT", Security.ContractOneofCase.Spread => "SPD", Security.ContractOneofCase.Synthetic => "SYN", _ => type.ToString(), }; /// /// Returns a shorthand string representation of a call or put appropriate for UIs (i.e. C or P). /// public static string format_call_put(PutOrCall call_put) => call_put.ToString()[..1]; #nullable enable /// /// Returns a concise string representation of a security expiration (using symbol-mapped /// expiration dates, and single-letter month codes) appropriate for UIs (e.g. es March 22, /// 2019: [Opt] [es] 22 Mar 19, or [Opt] [es] 22 H19). /// public static string format_expiration( DateTime exp_date, string? symbol = null, Security.ContractOneofCase? type = null, DateFormat date_format = DateFormat.DayMonthAbvDiff2000) { var result = Security.is_perpetual_exp(exp_date) ? "Perp" : DateFormatter.Format(exp_date, date_format); if (symbol is not null) { result = symbol + " " + result; } if (type.HasValue) { if (result.Length == 0) { result = format_security_type(type.Value); } else { result = $"[{format_security_type(type.Value)}] {result}"; } } return result; } /// /// Returns a concise string representation of a future trade appropriate for UIs. /// public static string format_future_trade( string symbol, DateTime exp_date, double size, double marginal_price) { var exp_str = format_expiration(exp_date, symbol: symbol); return $"{exp_str} {size} lots @ {marginal_price:C}"; } #nullable disable /// /// Returns a concise string representation of an option trade appropriate for UIs. /// public static string format_option_trade( string symbol, DateTime exp_date, double strike, bool is_call, double size, double marginal_price ) { var exp_str = format_expiration(exp_date, symbol: symbol); var cp_str = is_call ? "C" : "P"; return $"{exp_str} {strike} {cp_str} {size} lots @ {marginal_price:C}"; } static IEnumerable _format_legs(IEnumerable legs) { using var en = legs.GetEnumerator(); if (en.MoveNext()) { yield return _get_first_leg_name(en.Current); while (en.MoveNext()) yield return _get_subsequent_leg_name(en.Current); } } static string _get_first_leg_name(ContractLegImmutable leg) { string sec_str = leg.HasSecurity ? _format(leg.Security, false) : "NoSecurity"; return leg.signed_quantity() switch { 1.0 => sec_str, -1.0 => $"-{sec_str}", _ => $"{leg.signed_quantity()}{sec_str}", }; } static string _get_subsequent_leg_name(ContractLegImmutable leg) { string sec_str = leg.HasSecurity ? _format(leg.Security, false) : "NoSecurity"; return leg.signed_quantity() switch { 1.0 => $"+{sec_str}", -1.0 => $"-{sec_str}", _ => $"{leg.signed_quantity():+0.######;-0.######}{sec_str}", }; } } }