refactor: Rename Venue/SecType enums according to conventions

https://protobuf.dev/programming-guides/style/#enums
This commit is contained in:
John Colvin committed 2023-04-20 00:46:23 -04:00
1 parent c0980809c5
commit 5c25f9a3e5
33 files changed
+151 -135

No files matched your search

@@ -555,7 +555,7 @@ namespace mbts.analytics {
var rv = new HashSet<bts.api.SecurityTuple>();
foreach (var c in sc.Clauses)
foreach (var s in c.Symbols)
foreach (var e in c.Exchanges)
foreach (var e in c.Venues)
foreach (var st in c.SecurityTypes) {
var st_i = new bts.api.SecurityTuple();
st_i.Symbol = s;
@@ -568,4 +568,4 @@ namespace mbts.analytics {
#endregion
}
}
}
@@ -384,7 +384,7 @@ namespace mbts.spark {
public static bts.api.domain.SecurityCriteriaClause to_clause(
this SecurityCriteriaClause clause) {
var api_clause = new bts.api.domain.SecurityCriteriaClause();
api_clause.Exchanges.AddRange(
api_clause.Venues.AddRange(
clause.exchanges.empty_if_null().Select(e => e.to_api_venue()));
api_clause.Symbols.AddRange(clause.symbols.empty_if_null());
api_clause.Keys.AddRange(clause.security_keys.empty_if_null());
@@ -401,7 +401,7 @@ namespace mbts.spark {
public static SecurityCriteriaClause to_clause(
this bts.api.domain.SecurityCriteriaClause api_clause, Func<string, uint?>? try_resolve) {
return new(
api_clause.Exchanges.WrapSelectorRO(v => v.to_venue()).ToArray(),
api_clause.Venues.WrapSelectorRO(v => v.to_venue()).ToArray(),
api_clause.SecurityTypes.WrapSelectorRO(t => t.to_security_type()).ToArray(),
api_clause.Symbols.ToArray(),
null,
@@ -415,7 +415,7 @@ namespace mbts.spark {
public static SecurityCriteriaClause to_clause(
this bts.api.domain.SecurityCriteriaClauseImmutable api_clause) =>
new SecurityCriteriaClause(
api_clause.Exchanges.Select(v => v.to_venue()).ToArray(),
api_clause.Venues.Select(v => v.to_venue()).ToArray(),
api_clause.SecurityTypes.Select(t => t.to_security_type()).ToArray(),
api_clause.Symbols.ToArray(),
null,
@@ -134,7 +134,7 @@ namespace bts.api {
domain.SecurityType.Future => SecurityType.Future,
domain.SecurityType.Option => SecurityType.Option,
domain.SecurityType.Spread => SecurityType.Spread,
domain.SecurityType.Unset => SecurityType.Unset,
domain.SecurityType.Unspecified => SecurityType.Unset,
_ => throw new NotImplementedException(),
};
@@ -144,7 +144,7 @@ namespace bts.api {
SecurityType.Future => domain.SecurityType.Future,
SecurityType.Option => domain.SecurityType.Option,
SecurityType.Spread => domain.SecurityType.Spread,
SecurityType.Unset => domain.SecurityType.Unset,
SecurityType.Unset => domain.SecurityType.Unspecified,
_ => throw new NotImplementedException(),
};
@@ -158,7 +158,7 @@ namespace bts.api {
domain.Venue.BinanceUs => Venue.BinanceUs,
domain.Venue.BinanceUsdsFutures => Venue.BinanceUsdsFutures,
domain.Venue.Glbx => Venue.Glbx,
domain.Venue.None => Venue.Unset,
domain.Venue.Unspecified => Venue.Unset,
_ => throw new NotImplementedException(),
};
@@ -172,7 +172,7 @@ namespace bts.api {
Venue.BinanceUs => domain.Venue.BinanceUs,
Venue.BinanceUsdsFutures => domain.Venue.BinanceUsdsFutures,
Venue.Glbx => domain.Venue.Glbx,
Venue.Unset => domain.Venue.None,
Venue.Unset => domain.Venue.Unspecified,
_ => throw new NotImplementedException(),
};
+3
View File
@@ -34,6 +34,9 @@ if(WIN32 OR NOT ${BUILD_SPARKD})
api/*.cpp
config/*.cpp
core/*.cpp
domain/SecurityCriteria.cpp
domain/SecurityCriteriaClause.cpp
domain/DomainSecurityUtils.cpp
domain_model/*.cpp
expression/*.cpp
logging/*.cpp
@@ -7,7 +7,7 @@ import "lib/api/domain/SecurityType.proto";
option csharp_namespace = "bts.api.domain";
message SecurityCriteriaClause {
repeated bts.api.domain.Venue exchanges = 1;
repeated bts.api.domain.Venue venues = 1;
repeated bts.api.domain.SecurityType security_types = 2;
repeated string symbols = 3;
repeated uint32 keys = 4;
+6 -6
View File
@@ -4,10 +4,10 @@ package bts.api.domain;
option csharp_namespace = "bts.api.domain";
enum SecurityType {
UNSET = 0;
SPOT = 1;
FUTURE = 2;
SPREAD = 3;
OPTION = 4;
SYNTHETIC = 5;
SECURITY_TYPE_UNSPECIFIED = 0;
SECURITY_TYPE_SPOT = 1;
SECURITY_TYPE_FUTURE = 2;
SECURITY_TYPE_SPREAD = 3;
SECURITY_TYPE_OPTION = 4;
SECURITY_TYPE_SYNTHETIC = 5;
}
+13 -13
View File
@@ -9,18 +9,18 @@ option csharp_namespace = "bts.api.domain";
// a security within an exchange context. For cross-exchange integration, it
// might be useful to associate an exchange with a security id.
enum Venue {
VENUE_NONE = 0;
SIM = 1;
BTS = 2;
GLBX = 3;
DERIBIT = 4;
HUOBI = 5;
HUOBI_USDT_SWAP = 6;
HUOBI_COIN_SWAP = 7;
BINANCE = 8;
BINANCE_US = 9;
BINANCE_USDS_FUTURES = 10;
BINANCE_COIN_FUTURES = 11;
FTX = 12;
VENUE_UNSPECIFIED = 0;
VENUE_SIM = 1;
VENUE_BTS = 2;
VENUE_GLBX = 3;
VENUE_DERIBIT = 4;
VENUE_HUOBI = 5;
VENUE_HUOBI_USDT_SWAP = 6;
VENUE_HUOBI_COIN_SWAP = 7;
VENUE_BINANCE = 8;
VENUE_BINANCE_US = 9;
VENUE_BINANCE_USDS_FUTURES = 10;
VENUE_BINANCE_COIN_FUTURES = 11;
VENUE_FTX = 12;
VENUE_ICE = 13;
}
@@ -4,8 +4,8 @@ SecurityMetadataCollection {
scope {
clauses {
symbols: "BTC"
security_types: FUTURE
security_types: SPREAD
security_types: SECURITY_TYPE_FUTURE
security_types: SECURITY_TYPE_SPREAD
}
}
value {
@@ -27,7 +27,7 @@ SecurityMetadataCollection {
scope {
clauses {
symbols: "BTC"
security_types: OPTION
security_types: SECURITY_TYPE_OPTION
}
}
value {
+10 -23
View File
@@ -1,16 +1,3 @@
SymbolList {
value {
# This key is here for backwards compatability ONLY.
# If you need to update symbols you should update SymbolLists (plural)
symbol: "GC"
symbol: "SI"
symbol: "ES"
symbol: "BNB"
symbol: "BTC"
symbol: "ETH"
}
}
SymbolLists {
value {
list {
@@ -49,12 +36,12 @@ Symbols {
rule: "DeploymentType.type == 'DEMO' and System.platform == 'windows'"
value {
venues {
name: "SIM"
name: "VENUE_SIM"
future: @SymbolLists.list[GLBX].symbol
spread: @SymbolLists.list[GLBX].symbol
}
venues {
name: "SIMICE"
name: "VENUE_SIMICE"
future: @SymbolLists.list[ICE].symbol
spread: @SymbolLists.list[ICE].symbol
}
@@ -65,13 +52,13 @@ Symbols {
rule: "DeploymentType.type == 'PROD' and System.platform == 'windows'"
value {
venues {
name: "GLBX"
name: "VENUE_GLBX"
future: @SymbolLists.list[GLBX].symbol
spread: @SymbolLists.list[GLBX].symbol
option: @SymbolLists.list[GLBX].symbol
}
venues {
name: "ICE"
name: "VENUE_ICE"
future: @SymbolLists.list[ICE].symbol
spread: @SymbolLists.list[ICE].symbol
}
@@ -81,35 +68,35 @@ Symbols {
Symbols {
value {
venues {
name: "GLBX"
name: "VENUE_GLBX"
future: @SymbolLists.list[GLBX].symbol
spread: @SymbolLists.list[GLBX].symbol
option: @SymbolLists.list[GLBX].symbol
}
venues {
name: "SIM"
name: "VENUE_SIM"
future: @SymbolLists.list[GLBX].symbol
spread: @SymbolLists.list[GLBX].symbol
option: @SymbolLists.list[GLBX].symbol
}
venues {
name: "DERIBIT"
name: "VENUE_DERIBIT"
spot: @SymbolLists.list[DERIBIT].symbol
future: @SymbolLists.list[DERIBIT].symbol
option: @SymbolLists.list[DERIBIT].symbol
spread: @SymbolLists.list[DERIBIT].symbol
}
venues {
name: "BINANCE"
name: "VENUE_BINANCE"
spot: @SymbolLists.list[BINANCE].symbol
spread: @SymbolLists.list[BINANCE].symbol
}
venues {
name: "BINANCE_US"
name: "VENUE_BINANCE_US"
spot: @SymbolLists.list[BINANCE_US].symbol
}
venues {
name: "BINANCE_USDS_FUTURES"
name: "VENUE_BINANCE_USDS_FUTURES"
future: @SymbolLists.list[BINANCE_USDS_FUTURES].symbol
spread: @SymbolLists.list[BINANCE_USDS_FUTURES].symbol
}
+27 -26
View File
@@ -14,47 +14,50 @@
namespace bts::domain {
#define DOMAIN_VENUE(x) bts::api::domain::VENUE_##x
#define DOMAIN_SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
api::domain::Venue DomainSecurityUtils::convert(bts::api::Venue venue) {
switch (venue) {
case bts::api::Venue::VENUE_GLBX:
return bts::api::domain::Venue::GLBX;
return DOMAIN_VENUE(GLBX);
case bts::api::Venue::VENUE_DERIBIT:
return bts::api::domain::Venue::DERIBIT;
return DOMAIN_VENUE(DERIBIT);
case bts::api::Venue::VENUE_BTS:
return bts::api::domain::BTS;
return DOMAIN_VENUE(BTS);
case bts::api::Venue::VENUE_SIM:
return bts::api::domain::SIM;
return DOMAIN_VENUE(SIM);
case bts::api::Venue::VENUE_BINANCE:
return bts::api::domain::BINANCE;
return DOMAIN_VENUE(BINANCE);
case bts::api::Venue::VENUE_BINANCE_US:
return bts::api::domain::BINANCE_US;
return DOMAIN_VENUE(BINANCE_US);
case bts::api::VENUE_BINANCE_USDS_FUTURES:
return bts::api::domain::BINANCE_USDS_FUTURES;
return DOMAIN_VENUE(BINANCE_USDS_FUTURES);
default: {
LOG(md, Error, "convert unknown venue: {}", static_cast<int>(venue));
break;
}
}
return bts::api::domain::Venue::VENUE_NONE;
return DOMAIN_VENUE(UNSPECIFIED);
}
bts::api::Venue DomainSecurityUtils::convert(api::domain::Venue venue) {
switch (venue) {
case api::domain::Venue::GLBX:
case DOMAIN_VENUE(GLBX):
return api::Venue::VENUE_GLBX;
case api::domain::Venue::DERIBIT:
case DOMAIN_VENUE(DERIBIT):
return api::Venue::VENUE_DERIBIT;
case api::domain::Venue::FTX:
case DOMAIN_VENUE(FTX):
return api::Venue::VENUE_FTX;
case api::domain::Venue::BINANCE:
case DOMAIN_VENUE(BINANCE):
return api::Venue::VENUE_BINANCE;
case api::domain::Venue::BINANCE_US:
case DOMAIN_VENUE(BINANCE_US):
return api::Venue::VENUE_BINANCE_US;
case api::domain::Venue::BINANCE_USDS_FUTURES:
case DOMAIN_VENUE(BINANCE_USDS_FUTURES):
return api::Venue::VENUE_BINANCE_USDS_FUTURES;
case api::domain::Venue::SIM:
case DOMAIN_VENUE(SIM):
return api::Venue::VENUE_SIM;
case api::domain::Venue::VENUE_NONE:
case DOMAIN_VENUE(UNSPECIFIED):
return api::VENUE_UNSET;
default:
bts_assert(false);
@@ -66,22 +69,20 @@ bts::api::domain::SecurityType DomainSecurityUtils::convert(
bts::api::SecurityType sec_type) {
switch (sec_type) {
case bts::api::SecurityType::SECURITYTYPE_UNSET:
return bts::api::domain::SecurityType::UNSET;
return DOMAIN_SEC_TYPE(UNSPECIFIED);
case bts::api::SecurityType::SECURITYTYPE_STOCK:
return bts::api::domain::SecurityType::SPOT;
return DOMAIN_SEC_TYPE(SPOT);
case bts::api::SecurityType::SECURITYTYPE_OPTION:
return bts::api::domain::SecurityType::OPTION;
return DOMAIN_SEC_TYPE(OPTION);
case bts::api::SecurityType::SECURITYTYPE_FUTURE:
return bts::api::domain::SecurityType::FUTURE;
return DOMAIN_SEC_TYPE(FUTURE);
case bts::api::SecurityType::SECURITYTYPE_SPREAD:
return bts::api::domain::SecurityType::SPREAD;
return DOMAIN_SEC_TYPE(SPREAD);
case bts::api::SecurityType::SECURITYTYPE_SYNTHETIC:
return bts::api::domain::SecurityType::SYNTHETIC;
return DOMAIN_SEC_TYPE(SYNTHETIC);
default:
return bts::api::domain::SecurityType::UNSET;
bts_assert(false);
return DOMAIN_SEC_TYPE(UNSPECIFIED);
}
return bts::api::domain::SecurityType::UNSET;
}
bts::domain::FutureSecurity DomainSecurityUtils::convert(
@@ -165,4 +166,4 @@ std::string DomainSecurityUtils::get_exchange_id(const bts::api::Security &s) {
return "";
}
} // namespace bts::domain
} // namespace bts::domain
+8 -4
View File
@@ -11,6 +11,8 @@
namespace bts::domain {
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
class Security {
public:
SecurityCommon security_common;
@@ -57,15 +59,15 @@ constexpr SecurityID Security::id() const { return security_common.id; }
inline api::domain::SecurityType Security::type() const {
return std::visit(
overloaded{
[](const SpotSecurity &) { return api::domain::SecurityType::SPOT; },
[](const SpotSecurity &) { return SEC_TYPE(SPOT); },
[](const FutureSecurity &) {
return api::domain::SecurityType::FUTURE;
return SEC_TYPE(FUTURE);
},
[](const SpreadSecurity &) {
return api::domain::SecurityType::SPREAD;
return SEC_TYPE(SPREAD);
},
[](const OptionSecurity &) {
return api::domain::SecurityType::OPTION;
return SEC_TYPE(OPTION);
}},
security);
}
@@ -78,4 +80,6 @@ constexpr api::domain::Venue Security::venue() const {
return security_common.venue;
}
#undef SEC_TYPE
} // namespace bts::domain
+6 -3
View File
@@ -8,6 +8,9 @@
namespace bts::domain {
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
#define VENUE(x) bts::api::domain::VENUE_##x
using bts::api::domain::SecurityType;
// using bts::api::domain::Venue;
using std::string;
@@ -50,11 +53,11 @@ bool SecurityCriteriaClause::includes(
if (!is_defined()) {
return false;
}
if (venue != bts::api::domain::VENUE_NONE && !venues.empty() &&
if (venue != VENUE(UNSPECIFIED) && !venues.empty() &&
!CONTAINS(venues, venue)) {
return false;
}
if (type != SecurityType::UNSET && !security_types.empty() &&
if (type != SEC_TYPE(UNSPECIFIED) && !security_types.empty() &&
!CONTAINS(security_types, type)) {
return false;
}
@@ -67,7 +70,7 @@ bool SecurityCriteriaClause::includes(
SecurityCriteriaClause SecurityCriteriaClause::from_proto(
const api::domain::SecurityCriteriaClause &api_clause) {
SecurityCriteriaClause rv;
for (auto venue : api_clause.exchanges()) {
for (auto venue : api_clause.venues()) {
rv.venues.push_back(static_cast<api::domain::Venue>(venue));
}
for (auto type : api_clause.security_types()) {
+10 -8
View File
@@ -55,6 +55,8 @@ namespace bts::md {
using MDArray = std::array<PriceSize, COCONUT_MAX_DEPTH>;
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
// structs ////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
struct CCSecurityAuxData {
@@ -203,16 +205,16 @@ void GeneralMarketDataListener::on_securities(
}
bts_assert(search_result.exists_now);
switch (sec.type()) {
case bts::api::domain::SecurityType::SPOT:
case SEC_TYPE(SPOT):
_add_spot(sec);
break;
case bts::api::domain::SecurityType::FUTURE:
case SEC_TYPE(FUTURE):
_add_future(sec);
break;
case bts::api::domain::SecurityType::OPTION:
case SEC_TYPE(OPTION):
_add_option(sec);
break;
case bts::api::domain::SecurityType::SPREAD:
case SEC_TYPE(SPREAD):
_add_spread(sec);
break;
default:
@@ -334,7 +336,7 @@ SecurityIndexData *GeneralMarketDataListener::_find_handle(
}
void GeneralMarketDataListener::_add_future(const bts::domain::Security &sec) {
bts_assert(sec.type() == bts::api::domain::SecurityType::FUTURE);
bts_assert(sec.type() == SEC_TYPE(FUTURE));
auto search_result = _find_sec(sec, false);
bts_assert(search_result.existed_before);
FixedFutureSecurity ff_sec;
@@ -353,7 +355,7 @@ void GeneralMarketDataListener::_add_future(const bts::domain::Security &sec) {
}
void GeneralMarketDataListener::_add_option(const bts::domain::Security &sec) {
bts_assert(sec.type() == bts::api::domain::SecurityType::OPTION);
bts_assert(sec.type() == SEC_TYPE(OPTION));
auto search_result = _find_sec(sec, false);
bts_assert(search_result.existed_before);
FixedOptionSecurity fo_sec;
@@ -374,7 +376,7 @@ void GeneralMarketDataListener::_add_option(const bts::domain::Security &sec) {
}
void GeneralMarketDataListener::_add_spread(const bts::domain::Security &sec) {
bts_assert(sec.type() == bts::api::domain::SecurityType::SPREAD);
bts_assert(sec.type() == SEC_TYPE(SPREAD));
auto search_result = _find_sec(sec, false);
bts_assert(search_result.existed_before);
FixedSpreadSecurity fspr_sec;
@@ -408,7 +410,7 @@ void GeneralMarketDataListener::_add_spread(const bts::domain::Security &sec) {
void GeneralMarketDataListener::_add_spot(const bts::domain::Security &sec) {
LOG(md, Info, "GeneralMarketDataListener::_add_spot spot: {}",
sec.security_common.desc);
bts_assert(sec.type() == bts::api::domain::SecurityType::SPOT);
bts_assert(sec.type() == SEC_TYPE(SPOT));
auto search_result = _find_sec(sec, false);
bts_assert(search_result.existed_before);
FixedStockSecurity fs_sec;
+4
View File
@@ -3,6 +3,7 @@
#include "SecurityCache.h"
#include "UserSymbol.h"
#include "common.h"
#include "lib/domain/DomainSecurityUtils.h"
#include "lib/md/SymbolLoader.h"
#include "lib/md/protos/co2.pb.h"
#include "lib/utils/Dispatcher.h"
@@ -17,6 +18,9 @@ namespace md {
#define CAPI extern "C" BTS_EXPORT
using bts::domain::DomainSecurityUtils;
using bts::domain::SecurityCriteria;
//
// MDConsumer
+6 -3
View File
@@ -11,6 +11,9 @@
namespace bts::md {
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
#define VENUE(x) bts::api::domain::VENUE_##x
static domain::SecurityID create_sec_id(
api::domain::Venue venue, std::uint32_t exch_id) {
auto val = static_cast<std::uint64_t>(exch_id) |
@@ -94,8 +97,8 @@ bool SecurityStore::add_security(
api::domain::Venue venue,
api::domain::SecurityType type,
const std::string &symbol) {
if (venue == api::domain::Venue::VENUE_NONE || symbol.empty() ||
type == api::domain::SecurityType::UNSET) {
if (venue == VENUE(UNSPECIFIED) || symbol.empty() ||
type == SEC_TYPE(UNSPECIFIED)) {
return false;
}
return me_->cache.lock([&](auto &cache) {
@@ -107,7 +110,7 @@ bool SecurityStore::add_security(
s.security_common.venue = venue;
s.security_common.id = create_sec_id(venue, me_->id_counter++);
switch (type) {
case api::domain::SecurityType::FUTURE: {
case SEC_TYPE(FUTURE): {
s.security = domain::FutureSecurity();
break;
}
+4 -2
View File
@@ -23,6 +23,8 @@ using bts::domain::SecurityCriteria;
using bts::md::SecurityIDRecorder;
using bts::md::SymbolLoader;
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
struct SecurityLess {
bool operator()(const api::Security &left, const api::Security &right) {
return left.id() < right.id();
@@ -49,8 +51,8 @@ SyntheticSecurityService::SyntheticSecurityService(api::ServiceContext &context)
LOG(md, Info, "Initializing SyntheticSecurityService");
// load securities
const auto symbols = SymbolLoader::load(SecurityCriteria::create(
{}, {bts::api::domain::SecurityType::SYNTHETIC}));
const auto symbols =
SymbolLoader::load(SecurityCriteria::create({}, {SEC_TYPE(SYNTHETIC)}));
bts::md::db::load_securities(symbols, [=](const api::Security &security) {
if (security.Contract_case() == api::Security::kSynthetic) {
auto key = SecurityKey(security.id());
@@ -38,10 +38,11 @@ using std::string;
using std::unordered_set;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::BINANCE))
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE
#define BINANCE_MSG_TYPE_NAME(x) \
std::string { BinanceMessageType{x}.name() }
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
static ccapi::Request exchange_info_req() {
auto corr_id = CCApiCorrelationID::from_parts(
@@ -199,7 +200,7 @@ struct BinanceSecurityRequestor::PImpl {
validate_response(event, exch_info_req_pending);
LOG(md, Diag, "Received Binance exchange info (spots):\n{}",
event.toStringPretty());
update_securities<BinanceSpot>(msgs, {SecurityType::SPOT});
update_securities<BinanceSpot>(msgs, {SEC_TYPE(SPOT)});
exch_info_req_pending = false;
if (external_req_pending && !is_busy()) {
request();
+3 -1
View File
@@ -26,6 +26,8 @@ using std::string;
using std::stringstream;
using std::vector;
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
static std::string deduce_sym_from_name(const std::string &name) {
std::regex word_regex("(\\w+)");
auto words_begin =
@@ -68,7 +70,7 @@ void BinanceSpot::parse(
for (const auto &bspot : binance_spots) {
auto &sec = securities.emplace_back();
auto &scomm = sec.security_common;
scomm.type = SecurityType::SPOT;
scomm.type = SEC_TYPE(SPOT);
scomm.venue = venue;
scomm.exchange_sec_id = bspot.symbol;
+1 -1
View File
@@ -50,7 +50,7 @@ class BinanceSpot {
static void parse(
const ccapi::Message &msg,
std::vector<domain::Security> &securities,
api::domain::Venue venue = api::domain::Venue::BINANCE);
api::domain::Venue venue = api::domain::Venue::VENUE_BINANCE);
};
void from_json(const nlohmann::json &j, BinanceSpot &spot);
+1 -1
View File
@@ -57,7 +57,7 @@ using std::unique_ptr;
using std::unordered_map;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::BINANCE))
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE
/**
@@ -40,11 +40,12 @@ using std::string;
using std::unordered_set;
using std::vector;
#define VENUE Venue::BINANCE_US
#define VENUE_NAME (Venue_Name(Venue::BINANCE_US))
#define VENUE Venue::VENUE_BINANCE_US
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE_US))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE_US
#define BINANCE_MSG_TYPE_NAME(x) \
std::string { BinanceMessageType{x}.name() }
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
static ccapi::Request exchange_info_req() {
auto corr_id = CCApiCorrelationID::from_parts(
@@ -202,7 +203,7 @@ struct BinanceUsSecurityRequestor::PImpl {
validate_response(event, exch_info_req_pending);
LOG(md, Diag, "Received Binance US exchange info (spots):\n{}",
event.toStringPretty());
update_securities<BinanceSpot>(msgs, {SecurityType::SPOT});
update_securities<BinanceSpot>(msgs, {SEC_TYPE(SPOT)});
exch_info_req_pending = false;
if (external_req_pending && !is_busy()) {
request();
@@ -58,7 +58,7 @@ using std::unique_ptr;
using std::unordered_map;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::BINANCE_US))
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE_US))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE_US
/**
@@ -25,7 +25,8 @@ using bts::io::JsonReader;
using std::string;
using std::vector;
#define VENUE api::domain::Venue::BINANCE_USDS_FUTURES;
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
#define VENUE api::domain::Venue::VENUE_BINANCE_USDS_FUTURES;
static string deduce_sym_from_name(const string &name) {
const std::regex word_regex("(\\w+)");
@@ -72,7 +73,7 @@ void BinanceUsdsFuture::parse(
for (const auto &bf : binance_futs) {
auto &sec = securities.emplace_back();
auto &scomm = sec.security_common;
scomm.type = SecurityType::FUTURE;
scomm.type = SEC_TYPE(FUTURE);
scomm.venue = VENUE;
scomm.exchange_sec_id = bf.symbol;
@@ -27,7 +27,6 @@
namespace bts::md::binance_usds_futures {
using api::domain::SecurityType;
using api::domain::Venue;
using api::domain::Venue_Name;
using api::md::BinanceUsdsFuturesMarketDataConfig;
@@ -40,7 +39,7 @@ using std::string;
using std::unordered_set;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::BINANCE_USDS_FUTURES))
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE_USDS_FUTURES))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE_USDS_FUTURES
#define VENUE_PRICE_STATS_PATH BINANCE_USDS_FUTURES_PRICE_STATS_PATH
#define VENUE_INSTRUMENTS_PATH BINANCE_USDS_FUTURES_INSTRUMENTS_PATH
@@ -51,7 +51,7 @@ using std::unique_ptr;
using std::unordered_map;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::BINANCE_USDS_FUTURES))
#define VENUE_NAME (Venue_Name(Venue::VENUE_BINANCE_USDS_FUTURES))
#define CCAPI_VENUE_NAME CCAPI_EXCHANGE_NAME_BINANCE_USDS_FUTURES
#define VENUE_PRICE_STATS_PATH BINANCE_USDS_FUTURES_PRICE_STATS_PATH
+1 -1
View File
@@ -141,7 +141,7 @@ SecurityType infer_security_type(const string &label) {
const std::vector<CMEChannel> get_configured_cme_channels() {
// Get all glbx symbols
const auto symbols =
SymbolLoader::load(SecurityCriteria::create({api::domain::GLBX}));
SymbolLoader::load(SecurityCriteria::create({api::domain::VENUE_GLBX}));
return parse_channels({symbols.begin(), symbols.end()});
}
template <class T>
+3 -2
View File
@@ -17,7 +17,6 @@
namespace bts::md::ftx {
using bts::api::domain::Currency;
using bts::api::domain::Venue;
using bts::core::TableFormatter;
using bts::domain::FutureSecurity;
using bts::domain::Security;
@@ -26,6 +25,8 @@ using std::string;
using std::stringstream;
using std::vector;
#define VENUE bts::api::domain::VENUE_FTX
static std::string deduce_sym_from_name(const std::string &name) {
std::regex word_regex("(\\w+)");
auto words_begin =
@@ -79,7 +80,7 @@ void FTXFuture::parse(const ccapi::Message &msg, vector<Security> &securities) {
auto &sec = securities.emplace_back();
auto &scomm = sec.security_common;
scomm.type = ftx_fut.type.to_security_type();
scomm.venue = Venue::FTX;
scomm.venue = VENUE;
scomm.exchange_sec_id = ftx_fut.name;
scomm.desc = ftx_fut.name;
+9 -8
View File
@@ -20,6 +20,8 @@
namespace bts::md::ftx {
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
using bts::api::domain::Currency;
using bts::api::domain::Currency_Name;
using bts::api::domain::Currency_Parse;
@@ -77,7 +79,7 @@ void FTXMarket::parse(const ccapi::Message &msg, vector<Security> &securities) {
auto &sec = securities.emplace_back();
auto &scomm = sec.security_common;
scomm.desc = ftx_mkt.name;
scomm.venue = Venue::FTX;
scomm.venue = Venue::VENUE_FTX;
scomm.symbol = deduce_symbol(ftx_mkt);
scomm.asset = scomm.symbol;
@@ -89,29 +91,28 @@ void FTXMarket::parse(const ccapi::Message &msg, vector<Security> &securities) {
scomm.type = ftx_mkt.type.to_security_type();
switch (scomm.type) {
case SecurityType::UNSET:
case SEC_TYPE(UNSPECIFIED):
bts_assert_msgf(
false, "Failed to parse ftx security type from '{}'",
ftx_mkt.type);
break;
case api::domain::SPOT:
case SEC_TYPE(SPOT):
sec.security.emplace<domain::SpotSecurity>();
break;
case api::domain::FUTURE:
case SEC_TYPE(FUTURE):
sec.security.emplace<domain::FutureSecurity>();
break;
case api::domain::SPREAD:
case SEC_TYPE(SPREAD):
BTS_FATAL_MSG("Spreads not supported");
break;
case api::domain::OPTION:
case SEC_TYPE(OPTION):
BTS_FATAL_MSG("Options not supported");
break;
case api::domain::SYNTHETIC:
case SEC_TYPE(SYNTHETIC):
BTS_FATAL_MSG("Synthetics not supported");
break;
case api::domain::SecurityType_INT_MIN_SENTINEL_DO_NOT_USE_:
case api::domain::SecurityType_INT_MAX_SENTINEL_DO_NOT_USE_:
BTS_FATAL_MSGF("Bad security type value '{}'", scomm.type);
break;
}
+4 -3
View File
@@ -37,7 +37,8 @@ using std::string;
using std::unordered_set;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::FTX))
#define VENUE_NAME (Venue_Name(Venue::VENUE_FTX))
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
#define FTX_MSG_TYPE_NAME(x) \
std::string { FTXMessageType{x}.name() }
@@ -216,7 +217,7 @@ struct FTXSecurityRequestor::PImpl {
const CCApiCorrelationID & /*corr_id*/) {
validate_response(event, mkts_req_pending);
LOG(md, Diag, "Received FTX markets:\n{}", event.toStringPretty());
update_securities<FTXMarket>(msgs, {SecurityType::SPOT});
update_securities<FTXMarket>(msgs, {SEC_TYPE(SPOT)});
mkts_req_pending = false;
if (external_req_pending && !is_busy()) {
request();
@@ -234,7 +235,7 @@ struct FTXSecurityRequestor::PImpl {
const CCApiCorrelationID & /*corr_id*/) {
validate_response(event, futs_req_pending);
LOG(md, Diag, "Received FTX futures:\n{}", event.toStringPretty());
update_securities<FTXFuture>(msgs, {SecurityType::FUTURE});
update_securities<FTXFuture>(msgs, {SEC_TYPE(FUTURE)});
futs_req_pending = false;
if (external_req_pending && !is_busy()) {
request();
+3 -3
View File
@@ -48,15 +48,15 @@ ENUM_EQUALITY_OPS(FTXSecurityType)
constexpr api::domain::SecurityType FTXSecurityType::to_security_type() const {
switch (value) {
case SPOT:
return api::domain::SecurityType::SPOT;
return api::domain::SECURITY_TYPE_SPOT;
case FUTURE:
case PERPETUAL:
case PREDICTION:
case MOVE:
return api::domain::SecurityType::FUTURE;
return api::domain::SECURITY_TYPE_FUTURE;
case NONE:
default:
return api::domain::SecurityType::UNSET;
return api::domain::SECURITY_TYPE_UNSPECIFIED;
}
}
+1 -1
View File
@@ -47,7 +47,7 @@ using std::unique_ptr;
using std::unordered_map;
using std::vector;
#define VENUE_NAME (Venue_Name(Venue::FTX))
#define VENUE_NAME (Venue_Name(Venue::VENUE_FTX))
#define FTX_MSG_TYPE_NAME(x) \
std::string { FTXMessageType{x}.name() }
+1 -1
View File
@@ -60,7 +60,7 @@ static void run_onixs(
std::vector<std::shared_ptr<bts::md::IMDPlatform>> platforms;
// get all glbx symbols
auto cme_symbols =
SymbolLoader::load(SecurityCriteria::create({api::domain::GLBX}));
SymbolLoader::load(SecurityCriteria::create({api::domain::VENUE_GLBX}));
if (!cme_symbols.empty()) {
auto *main = new bts::md::MDP3Main();
main->start(
+1 -1
View File
@@ -53,7 +53,7 @@ Tail::Tail() :
callback([&] {
const auto products = SymbolLoader::load(SecurityCriteria::create(
{}, {bts::api::domain::SecurityType::FUTURE}));
{}, {bts::api::domain::SECURITY_TYPE_FUTURE}));
bts::md::run_periodic_dumper(
products, _args->mod, _args->format, _args->all, _args->qualifier);
});